trackler 2.2.0.0 → 2.2.0.1

data/tracks/ecmascript/exercises/robot-simulator/robot-simulator.spec.js

@@ -1,136 +1,136 @@
 import Robot from './robot-simulator';
 
-describe('Robot', function() {
-  let robot = new Robot();
+describe('Robot', () => {
+  const robot = new Robot();
 
-  test('robot bearing', function() {
-    const directions = [ 'east', 'west', 'north', 'south' ];
+  test('robot bearing', () => {
+    const directions = ['east', 'west', 'north', 'south'];
 
-    directions.forEach(currentDirection => {
+    directions.forEach((currentDirection) => {
       robot.orient(currentDirection);
       expect(robot.bearing).toEqual(currentDirection);
     });
   });
 
-  xtest('invalid robot bearing', function() {
+  xtest('invalid robot bearing', () => {
     try {
       robot.orient('crood');
-    } catch(exception) {
+    } catch (exception) {
       expect(exception).toEqual('Invalid Robot Bearing');
     }
   });
 
-  xtest('turn right from north', function() {
+  xtest('turn right from north', () => {
     robot.orient('north');
     robot.turnRight();
     expect(robot.bearing).toEqual('east');
   });
 
-  xtest('turn right from east', function() {
+  xtest('turn right from east', () => {
     robot.orient('east');
     robot.turnRight();
     expect(robot.bearing).toEqual('south');
   });
 
-  xtest('turn right from south', function() {
+  xtest('turn right from south', () => {
     robot.orient('south');
     robot.turnRight();
     expect(robot.bearing).toEqual('west');
   });
 
-  xtest('turn right from west', function() {
+  xtest('turn right from west', () => {
     robot.orient('west');
     robot.turnRight();
     expect(robot.bearing).toEqual('north');
   });
 
-  xtest('turn left from north', function() {
+  xtest('turn left from north', () => {
     robot.orient('north');
     robot.turnLeft();
     expect(robot.bearing).toEqual('west');
   });
 
-  xtest('turn left from east', function() {
+  xtest('turn left from east', () => {
     robot.orient('east');
     robot.turnLeft();
     expect(robot.bearing).toEqual('north');
   });
 
-  xtest('turn left from south', function() {
+  xtest('turn left from south', () => {
     robot.orient('south');
     robot.turnLeft();
     expect(robot.bearing).toEqual('east');
   });
 
-  xtest('turn left from west', function() {
+  xtest('turn left from west', () => {
     robot.orient('west');
     robot.turnLeft();
     expect(robot.bearing).toEqual('south');
   });
 
-  xtest('robot coordinates', function() {
+  xtest('robot coordinates', () => {
     robot.at(3, 0);
     expect(robot.coordinates).toEqual([3, 0]);
   });
 
-  xtest('other robot coordinates', function() {
+  xtest('other robot coordinates', () => {
     robot.at(-2, 5);
     expect(robot.coordinates).toEqual([-2, 5]);
   });
 
-  xtest('advance when facing north', function() {
+  xtest('advance when facing north', () => {
     robot.at(0, 0);
     robot.orient('north');
     robot.advance();
     expect(robot.coordinates).toEqual([0, 1]);
   });
 
-  xtest('advance when facing east', function() {
+  xtest('advance when facing east', () => {
     robot.at(0, 0);
     robot.orient('east');
     robot.advance();
     expect(robot.coordinates).toEqual([1, 0]);
   });
 
-  xtest('advance when facing south', function() {
+  xtest('advance when facing south', () => {
     robot.at(0, 0);
     robot.orient('south');
     robot.advance();
     expect(robot.coordinates).toEqual([0, -1]);
   });
 
-  xtest('advance when facing west', function() {
+  xtest('advance when facing west', () => {
     robot.at(0, 0);
     robot.orient('west');
     robot.advance();
     expect(robot.coordinates).toEqual([-1, 0]);
   });
 
-  xtest('instructions for turning left', function() {
-    expect(robot.instructions('L')).toEqual([ 'turnLeft' ]);
+  xtest('instructions for turning left', () => {
+    expect(robot.instructions('L')).toEqual(['turnLeft']);
   });
 
-  xtest('instructions for turning right', function() {
-    expect(robot.instructions('R')).toEqual([ 'turnRight' ]);
+  xtest('instructions for turning right', () => {
+    expect(robot.instructions('R')).toEqual(['turnRight']);
   });
 
-  xtest('instructions for advancing', function() {
-    expect(robot.instructions('A')).toEqual([ 'advance' ]);
+  xtest('instructions for advancing', () => {
+    expect(robot.instructions('A')).toEqual(['advance']);
   });
 
-  xtest('series of instructions', function() {
+  xtest('series of instructions', () => {
     expect(robot.instructions('RAAL'))
-      .toEqual([ 'turnRight', 'advance', 'advance', 'turnLeft' ]);
+      .toEqual(['turnRight', 'advance', 'advance', 'turnLeft']);
   });
 
-  xtest('instruct robot', function() {
+  xtest('instruct robot', () => {
     robot.place({ x: -2, y: 1, direction: 'east' });
     robot.evaluate('RLAALAL');
     expect(robot.coordinates).toEqual([0, 2]);
     expect(robot.bearing).toEqual('west');
   });
 
-  xtest('instruct many robots', function() {
+  xtest('instruct many robots', () => {
     const robot1 = new Robot();
     const robot2 = new Robot();
     const robot3 = new Robot();
@@ -150,5 +150,4 @@ describe('Robot', function() {
     expect(robot3.coordinates).toEqual([11, 5]);
     expect(robot3.bearing).toEqual('north');
   });
-
 });

data/tracks/ecmascript/exercises/roman-numerals/example.js

@@ -1,25 +1,25 @@
 function toRoman(number) {
   let result = '';
   const mappings = [
-    { arabic: 1000, roman:  'M' },
-    { arabic:  900, roman: 'CM' },
-    { arabic:  500, roman:  'D' },
-    { arabic:  400, roman: 'CD' },
-    { arabic:  100, roman:  'C' },
-    { arabic:   90, roman: 'XC' },
-    { arabic:   50, roman:  'L' },
-    { arabic:   40, roman: 'XL' },
-    { arabic:   10, roman:  'X' },
-    { arabic:    9, roman: 'IX' },
-    { arabic:    5, roman:  'V' },
-    { arabic:    4, roman: 'IV' },
-    { arabic:    1, roman:  'I' }
+    { arabic: 1000, roman: 'M' },
+    { arabic: 900, roman: 'CM' },
+    { arabic: 500, roman: 'D' },
+    { arabic: 400, roman: 'CD' },
+    { arabic: 100, roman: 'C' },
+    { arabic: 90, roman: 'XC' },
+    { arabic: 50, roman: 'L' },
+    { arabic: 40, roman: 'XL' },
+    { arabic: 10, roman: 'X' },
+    { arabic: 9, roman: 'IX' },
+    { arabic: 5, roman: 'V' },
+    { arabic: 4, roman: 'IV' },
+    { arabic: 1, roman: 'I' },
   ];
 
-  mappings.forEach(mapping => {
+  mappings.forEach((mapping) => {
     while (number >= mapping.arabic) {
-      result = result + mapping.roman;
-      number = number - mapping.arabic;
+      result += mapping.roman;
+      number -= mapping.arabic;
     }
   });
 

data/tracks/ecmascript/exercises/saddle-points/saddle-points.spec.js

@@ -3,7 +3,7 @@ import Matrix from './saddle-points';
 describe('Matrix', () => {
   test('extracts a row', () => {
     const matrix = new Matrix('1 2\n10 20');
-    expect(matrix.rows[0]).toEqual([1,2]);
+    expect(matrix.rows[0]).toEqual([1, 2]);
   });
 
   xtest('extracts other row', () => {
@@ -28,12 +28,12 @@ describe('Matrix', () => {
 
   xtest('a saddle point', () => {
     const matrix = new Matrix('1 2\n3 4');
-    expect(matrix.saddlePoints).toEqual([[0,1]]);
+    expect(matrix.saddlePoints).toEqual([[0, 1]]);
   });
 
   xtest('another saddle point', () => {
     const matrix = new Matrix('18 3 39 19 91\n38 10 8 77 320\n3 4 8 6 7');
-    expect(matrix.saddlePoints).toEqual([[2,2]]);
+    expect(matrix.saddlePoints).toEqual([[2, 2]]);
   });
 
   xtest('multiple saddle points', () => {

data/tracks/ecmascript/exercises/say/example.js

@@ -1,14 +1,14 @@
 const smallNumbers = {
-  0:  'zero',
-  1:  'one',
-  2:  'two',
-  3:  'three',
-  4:  'four',
-  5:  'five',
-  6:  'six',
-  7:  'seven',
-  8:  'eight',
-  9:  'nine',
+  0: 'zero',
+  1: 'one',
+  2: 'two',
+  3: 'three',
+  4: 'four',
+  5: 'five',
+  6: 'six',
+  7: 'seven',
+  8: 'eight',
+  9: 'nine',
   10: 'ten',
   11: 'eleven',
   12: 'twelve',
@@ -18,7 +18,7 @@ const smallNumbers = {
   16: 'sixteen',
   17: 'seventeen',
   18: 'eighteen',
-  19: 'nineteen'
+  19: 'nineteen',
 };
 
 const decades = {
@@ -29,31 +29,32 @@ const decades = {
   60: 'sixty',
   70: 'seventy',
   80: 'eighty',
-  90: 'ninety'
+  90: 'ninety',
 };
 
 const bigNumbers = {
-  1000:       'thousand',
-  1000000:    'million',
-  1000000000: 'billion'
+  1000: 'thousand',
+  1000000: 'million',
+  1000000000: 'billion',
 };
 
 function bigPart(number) {
-  let factor, result = '';
+  let factor,
+    result = '';
   for (let bigNumber = 1000000000; bigNumber >= 1000; bigNumber /= 1000) {
     if (number.current >= bigNumber) {
       factor = Math.floor(number.current / bigNumber);
-      result += threeDigit(factor) + ' ' + bigNumbers[bigNumber] + ' ';
-      number.current = number.current - factor * bigNumber;
+      result += `${threeDigit(factor)} ${bigNumbers[bigNumber]} `;
+      number.current -= factor * bigNumber;
     }
   }
   return result;
 }
 
-const sayDecade = n => {
+const sayDecade = (n) => {
   for (let decade = 90; decade >= 20; decade -= 10) {
     if (n >= decade) {
-      return decades[decade] + '-' + smallNumbers[n - decade];
+      return `${decades[decade]}-${smallNumbers[n - decade]}`;
     }
   }
 };
@@ -61,19 +62,18 @@ const sayDecade = n => {
 const twoDigit = n => n < 20 ? smallNumbers[n] : sayDecade(n);
 
 const threeDigit = n => n < 100 ? twoDigit(n)
-  : smallNumbers[Math.floor(n / 100)] + ' hundred ' + twoDigit(n % 100);
+  : `${smallNumbers[Math.floor(n / 100)]} hundred ${twoDigit(n % 100)}`;
 
 export default class Say {
   inEnglish(n) {
     let result;
-    const number = {current: n};
+    const number = { current: n };
 
-    if (0 <= n && n < 1000000000000) {
+    if (n >= 0 && n < 1000000000000) {
       result = bigPart(number);
       result += threeDigit(number.current);
       return result.replace(/.zero/, '');
-    } else {
-      throw new Error('Number must be between 0 and 999,999,999,999.');
     }
+    throw new Error('Number must be between 0 and 999,999,999,999.');
   }
 }

data/tracks/ecmascript/exercises/say/say.spec.js

@@ -65,14 +65,13 @@ describe('say', () => {
 
   xtest('raises an error below zero', () => {
     expect(() => {
-      say.inEnglish(-1)
+      say.inEnglish(-1);
     }).toThrow(new Error('Number must be between 0 and 999,999,999,999.'));
   });
 
   xtest('raises an error above 999,999,999,999', () => {
     expect(() => {
-      say.inEnglish(1000000000000)
+      say.inEnglish(1000000000000);
     }).toThrow(new Error('Number must be between 0 and 999,999,999,999.'));
   });
-
 });

data/tracks/ecmascript/exercises/scrabble-score/example.js

@@ -1,17 +1,35 @@
 const letterScores = {
-  a : 1, e : 1, i : 1, o : 1,
-  u : 1, l : 1, n : 1, r : 1,
-  s : 1, t : 1, d : 2, g : 2,
-  b : 3, c : 3, m : 3, p : 3,
-  f : 4, h : 4, v : 4, w : 4,
-  y : 4, k : 5, j : 8, x : 8,
-  q : 10, z : 10
+  a: 1,
+  e: 1,
+  i: 1,
+  o: 1,
+  u: 1,
+  l: 1,
+  n: 1,
+  r: 1,
+  s: 1,
+  t: 1,
+  d: 2,
+  g: 2,
+  b: 3,
+  c: 3,
+  m: 3,
+  p: 3,
+  f: 4,
+  h: 4,
+  v: 4,
+  w: 4,
+  y: 4,
+  k: 5,
+  j: 8,
+  x: 8,
+  q: 10,
+  z: 10,
 };
 
-const letterScore = (letter) => letterScores[letter] || 0;
+const letterScore = letter => letterScores[letter] || 0;
 
 export default (word) => {
-
   word = word ? word.toLowerCase() : '';
 
   let sum = 0;

data/tracks/ecmascript/exercises/scrabble-score/scrabble-score.spec.js

@@ -1,16 +1,15 @@
 import score from './scrabble-score';
 
-describe('Scrabble', function() {
-  test('scores an empty word as zero',() => expect(score('')).toEqual(0));
+describe('Scrabble', () => {
+  test('scores an empty word as zero', () => expect(score('')).toEqual(0));
 
-  xtest('scores a null as zero',() => expect(score(null)).toEqual(0));
+  xtest('scores a null as zero', () => expect(score(null)).toEqual(0));
 
-  xtest('scores a very short word',() => expect(score('a')).toEqual(1));
+  xtest('scores a very short word', () => expect(score('a')).toEqual(1));
 
   xtest('scores the word by the number of letters', () => expect(score('street')).toEqual(6));
 
-  xtest('scores more complicated words with more',() => expect(score('quirky')).toEqual(22));
-
-  xtest('scores case insensitive words',() => expect(score('OXYPHENBUTAZONE')).toEqual(41));
+  xtest('scores more complicated words with more', () => expect(score('quirky')).toEqual(22));
 
+  xtest('scores case insensitive words', () => expect(score('OXYPHENBUTAZONE')).toEqual(41));
 });

data/tracks/ecmascript/exercises/secret-handshake/example.js

@@ -1,5 +1,5 @@
 export default function (handshake) {
-  const HANDSHAKE_COMMANDS = [ 'wink', 'double blink', 'close your eyes', 'jump', 'REVERSE' ]
+  const HANDSHAKE_COMMANDS = ['wink', 'double blink', 'close your eyes', 'jump', 'REVERSE'];
 
   if (typeof handshake !== 'number') {
     throw new Error('Handshake must be a number');
@@ -12,7 +12,7 @@ export default function (handshake) {
 
     for (let i = 0; i < HANDSHAKE_COMMANDS.length; i++) {
       const currentCommand = HANDSHAKE_COMMANDS[i];
-      const handshakeHasCommand = handshake & Math.pow(2,i);
+      const handshakeHasCommand = handshake & Math.pow(2, i);
 
       if (handshakeHasCommand) {
         if (currentCommand === 'REVERSE') {
@@ -27,5 +27,4 @@ export default function (handshake) {
   };
 
   this.shakeWith = this.calculateHandshake(handshake);
-
 }

data/tracks/ecmascript/exercises/secret-handshake/secret-handshake.spec.js

@@ -1,7 +1,6 @@
 import SecretHandshake from './secret-handshake';
 
 describe('Secret Handshake', () => {
-
   test('binary 1 (hexadecimal 0x01) is a wink', () => {
     const handshake = new SecretHandshake(0x01);
     expect(handshake.commands()).toEqual(['wink']);
@@ -24,23 +23,22 @@ describe('Secret Handshake', () => {
 
   xtest('binary 11 (hexadecimal 0x03) is wink and double blink', () => {
     const handshake = new SecretHandshake(0x03);
-    expect(handshake.commands()).toEqual(['wink','double blink']);
+    expect(handshake.commands()).toEqual(['wink', 'double blink']);
   });
 
   xtest('binary 10011 (hexadecimal 0x13) is double blink and wink', () => {
     const handshake = new SecretHandshake(0x13);
-    expect(handshake.commands()).toEqual(['double blink','wink']);
+    expect(handshake.commands()).toEqual(['double blink', 'wink']);
   });
 
   xtest('binary 11111 (hexadecimal 0x1F) is jump, close your eyes, double blink, and wink', () => {
     const handshake = new SecretHandshake(0x1F);
-    expect(handshake.commands()).toEqual(['jump','close your eyes','double blink','wink']);
+    expect(handshake.commands()).toEqual(['jump', 'close your eyes', 'double blink', 'wink']);
   });
 
   xtest('text is an invalid secret handshake', () => {
     expect(() => new SecretHandshake('piggies'))
       .toThrow(new Error('Handshake must be a number'));
   });
-
 });
 

data/tracks/ecmascript/exercises/series/series.spec.js

@@ -1,7 +1,6 @@
 import Series from './series';
 
 describe('Series', () => {
-
   test('has digits (short)', () => {
     expect(new Series('01234').digits).toEqual([0, 1, 2, 3, 4]);
   });
@@ -52,9 +51,8 @@ describe('Series', () => {
   });
 
   xtest('throws an error if not enough digits to slice', () => {
-    expect( () => {
+    expect(() => {
       new Series('01032987583').slices(12);
     }).toThrow(new Error('Slice size is too big.'));
   });
-
 });

data/tracks/ecmascript/exercises/sieve/example.js

@@ -1,7 +1,7 @@
 function newArrayWithRange(first, last) {
   let i;
   const array = [];
-  for ( i = first; i <= last; i++ ) {
+  for (i = first; i <= last; i++) {
     array.push(i);
   }
   return array;
@@ -12,7 +12,8 @@ function indivisibleBy(value) {
 }
 
 function sieve(n) {
-  let prime, possibilities;
+  let prime,
+    possibilities;
   const primes = [];
 
   possibilities = newArrayWithRange(2, n);
@@ -20,7 +21,7 @@ function sieve(n) {
   do {
     prime = possibilities.shift();
     primes.push(prime);
-    possibilities = possibilities.filter( indivisibleBy, prime );
+    possibilities = possibilities.filter(indivisibleBy, prime);
   } while (possibilities.length > 0);
 
   return primes;

data/tracks/ecmascript/exercises/sieve/sieve.spec.js

@@ -1,7 +1,6 @@
 import Sieve from './sieve';
 
 describe('Sieve', () => {
-
   test('finds primes up to 10', () => {
     expect(new Sieve(10).primes).toEqual([2, 3, 5, 7]);
   });
@@ -13,5 +12,4 @@ describe('Sieve', () => {
   xtest('finds primes up to 1000', () => {
     expect(new Sieve(1000).primes).toEqual([2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]);
   });
-
 });

data/tracks/ecmascript/exercises/simple-cipher/example.js

@@ -1,7 +1,7 @@
 const ALPHA = 'abcdefghijklmnopqrstuvwxyz';
 
 function generateKey() {
-  return Array.apply(null, Array(100))
+  return Array(...Array(100))
     .map(() => ALPHA[Math.floor(Math.random() * ALPHA.length)])
     .join('');
 }
@@ -18,20 +18,19 @@ function xCode(key, inText, sign) {
 const mod = (n, m) => (n % m + m) % m;
 
 export default function (key) {
-
   if (typeof key === 'undefined') {
     key = generateKey();
-  } else if (key.length === 0 || key.match(/[^a-z]/, "g")) {
-    throw new Error("Bad key");
+  } else if (key.length === 0 || key.match(/[^a-z]/, 'g')) {
+    throw new Error('Bad key');
   }
 
   return {
-    key:    key,
-    encode: function (plainText) {
+    key,
+    encode(plainText) {
       return xCode(this.key, plainText, 1);
     },
-    decode: function (encodedText) {
+    decode(encodedText) {
       return xCode(this.key, encodedText, -1);
-    }
-  }
+    },
+  };
 }

data/tracks/ecmascript/exercises/simple-cipher/simple-cipher.spec.js

@@ -1,6 +1,6 @@
 import Cipher from './simple-cipher';
 
-describe('Random key cipher',  () => {
+describe('Random key cipher', () => {
   const cipher = new Cipher();
 
   test('has a key made of letters', () => {
@@ -26,19 +26,19 @@ describe('Random key cipher',  () => {
 
 describe('Incorrect key cipher', () => {
   xtest('throws an error with an all caps key', () => {
-    expect( () => {
+    expect(() => {
       new Cipher('ABCDEF');
     }).toThrow(new Error('Bad key'));
   });
 
   xtest('throws an error with a numeric key', () => {
-    expect( () => {
+    expect(() => {
       new Cipher('12345');
     }).toThrow(new Error('Bad key'));
   });
 
   xtest('throws an error with an empty key', () => {
-    expect( () => {
+    expect(() => {
       new Cipher('');
     }).toThrow(new Error('Bad key'));
   });

data/tracks/ecmascript/exercises/space-age/example.js

@@ -6,7 +6,7 @@ const EARTH_TO_OTHER_PLANETS = {
   jupiter: 11.862615,
   saturn: 29.447498,
   uranus: 84.016846,
-  neptune: 164.79132
+  neptune: 164.79132,
 };
 
 class SpaceAge {