trackler 2.2.0.0 → 2.2.0.1

data/tracks/ecmascript/exercises/circular-buffer/circular-buffer.spec.js

@@ -2,17 +2,16 @@ import circularBuffer from './circular-buffer';
 import { BufferFullError, BufferEmptyError } from './circular-buffer';
 
 describe('CircularBuffer', () => {
-
   test('reading an empty buffer throws a BufferEmptyError', () => {
     const buffer = circularBuffer(1);
-    expect(()=>buffer.read()).toThrow(BufferEmptyError);
+    expect(() => buffer.read()).toThrow(BufferEmptyError);
   });
 
   xtest('write and read back one item', () => {
     const buffer = circularBuffer(1);
     buffer.write('1');
     expect(buffer.read()).toBe('1');
-    expect(()=>buffer.read()).toThrow(BufferEmptyError);
+    expect(() => buffer.read()).toThrow(BufferEmptyError);
   });
 
   xtest('write and read back multiple items', () => {
@@ -21,7 +20,7 @@ describe('CircularBuffer', () => {
     buffer.write('2');
     expect(buffer.read()).toBe('1');
     expect(buffer.read()).toBe('2');
-    expect(()=>buffer.read()).toThrow(BufferEmptyError);
+    expect(() => buffer.read()).toThrow(BufferEmptyError);
   });
 
   xtest('clearing a buffer', () => {
@@ -29,7 +28,7 @@ describe('CircularBuffer', () => {
     buffer.write('1');
     buffer.write('2');
     buffer.clear();
-    expect(()=>buffer.read()).toThrow(BufferEmptyError);
+    expect(() => buffer.read()).toThrow(BufferEmptyError);
     buffer.write('3');
     buffer.write('4');
     expect(buffer.read()).toBe('3');
@@ -58,7 +57,7 @@ describe('CircularBuffer', () => {
     const buffer = circularBuffer(3);
     buffer.write(null);
     buffer.write(undefined);
-    [1,2,3].map(i => buffer.write(i.toString()));
+    [1, 2, 3].map(i => buffer.write(i.toString()));
     expect(buffer.read()).toBe('1');
   });
 
@@ -76,7 +75,7 @@ describe('CircularBuffer', () => {
     buffer.forceWrite('A');
     expect(buffer.read()).toBe('2');
     expect(buffer.read()).toBe('A');
-    expect(()=>buffer.read()).toThrow(BufferEmptyError);
+    expect(() => buffer.read()).toThrow(BufferEmptyError);
   });
 
   xtest('forced writes act like write in a non-full buffer', () => {
@@ -85,17 +84,17 @@ describe('CircularBuffer', () => {
     buffer.forceWrite('2');
     expect(buffer.read()).toBe('1');
     expect(buffer.read()).toBe('2');
-    expect(()=>buffer.read()).toThrow(BufferEmptyError);
+    expect(() => buffer.read()).toThrow(BufferEmptyError);
   });
 
   xtest('alternate force write and read into full buffer', () => {
     const buffer = circularBuffer(5);
-    [1,2,3].map(i => buffer.write(i.toString()));
+    [1, 2, 3].map(i => buffer.write(i.toString()));
     buffer.read();
     buffer.read();
     buffer.write('4');
     buffer.read();
-    [5,6,7,8].map(i => buffer.write(i.toString()));
+    [5, 6, 7, 8].map(i => buffer.write(i.toString()));
     buffer.forceWrite('A');
     buffer.forceWrite('B');
     expect(buffer.read()).toBe('6');
@@ -103,7 +102,6 @@ describe('CircularBuffer', () => {
     expect(buffer.read()).toBe('8');
     expect(buffer.read()).toBe('A');
     expect(buffer.read()).toBe('B');
-    expect(()=>buffer.read()).toThrow(BufferEmptyError);
+    expect(() => buffer.read()).toThrow(BufferEmptyError);
   });
-
 });

data/tracks/ecmascript/exercises/circular-buffer/example.js

@@ -1,34 +1,35 @@
-let buffer, bufferMax;
+let buffer,
+  bufferMax;
 
 export class BufferEmptyError extends Error {
   constructor(message) {
     super();
     this.message = message || 'Buffer is empty.';
   }
-};
+}
 export class BufferFullError extends Error {
   constructor(message) {
     super();
     this.message = message || 'Buffer is full.';
   }
-};
+}
 
 const read = () => {
-  if (buffer.length === 0){
+  if (buffer.length === 0) {
     throw new BufferEmptyError();
   }
-  return buffer.splice(0,1)[0];
+  return buffer.splice(0, 1)[0];
 };
 
 const write = (value) => {
-  if (buffer.length === bufferMax){
+  if (buffer.length === bufferMax) {
     throw new BufferFullError();
   }
   value ? buffer.push(value) : null;
 };
 
 const forceWrite = (value) => {
-  if (buffer.length === bufferMax){
+  if (buffer.length === bufferMax) {
     read();
   }
   write(value);
@@ -40,10 +41,10 @@ const CircularBuffer = (capacity) => {
   buffer = [];
   bufferMax = capacity;
   return {
-    read: read,
-    write: write,
-    forceWrite: forceWrite,
-    clear: clear
+    read,
+    write,
+    forceWrite,
+    clear,
   };
 };
 

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

@@ -1,9 +1,7 @@
 import at from './clock';
 
 describe('Clock', () => {
-
   describe('Creating a new clock with an initial time', () => {
-
     test('on the hour', () => {
       expect(at(8).toString()).toEqual('08:00');
     });
@@ -81,7 +79,6 @@ describe('Clock', () => {
     });
 
     describe('Adding and subtracting minutes', () => {
-
       xtest('add minutes', () => {
         expect(at(10, 0).plus(3).toString()).toEqual('10:03');
       });
@@ -145,11 +142,9 @@ describe('Clock', () => {
       xtest('subtract more than two days', () => {
         expect(at(2, 20).minus(3000).toString()).toEqual('00:20');
       });
-
     });
 
     describe('Construct two separate clocks, set times, test if they are equal', () => {
-
       xtest('clocks with same time', () => {
         expect(at(15, 37).equals(at(15, 37))).toBeTruthy();
       });
@@ -209,9 +204,6 @@ describe('Clock', () => {
       xtest('clocks with negative hours and minutes that wrap', () => {
         expect(at(18, 7).equals(at(-54, -11513))).toBeTruthy();
       });
-
     });
-
   });
-
 });

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

@@ -1,15 +1,15 @@
-export default function(hour, minute) {
+export default function (hour, minute) {
   const MINUTESPERDAY = 1440;
   const HOURSPERDAY = 24;
 
-  let clock = {
-    hour:   hour,
-    minute: minute || 0
+  const clock = {
+    hour,
+    minute: minute || 0,
   };
 
   function formatNum(num) {
     const numString = num.toString();
-    return numString.length === 1 ? "0" + numString : numString;
+    return numString.length === 1 ? `0${numString}` : numString;
   }
 
   function adjustTime(delta) {
@@ -27,10 +27,10 @@ export default function(hour, minute) {
   adjustTime(0);
 
   return {
-    clock:    clock,
-    toString: () => formatNum(clock.hour) + ":" + formatNum(clock.minute),
-    plus:     function(minutes) { adjustTime(minutes); return this; },
-    minus:    function(minutes) { adjustTime(-minutes); return this; },
-    equals:   (otherClock) => clock.hour === otherClock.clock.hour && clock.minute === otherClock.clock.minute
-  }
+    clock,
+    toString: () => `${formatNum(clock.hour)}:${formatNum(clock.minute)}`,
+    plus(minutes) { adjustTime(minutes); return this; },
+    minus(minutes) { adjustTime(-minutes); return this; },
+    equals: otherClock => clock.hour === otherClock.clock.hour && clock.minute === otherClock.clock.minute,
+  };
 }

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

@@ -1,110 +1,108 @@
 import Board from './connect';
 
 describe('Judging a game of connect', () => {
-
-  test("an empty board has no winner", () => {
-    let board = [
-      ". . . . .",
-      " . . . . .",
-      "  . . . . .",
-      "   . . . . .",
-      "    . . . . ."
+  test('an empty board has no winner', () => {
+    const board = [
+      '. . . . .',
+      ' . . . . .',
+      '  . . . . .',
+      '   . . . . .',
+      '    . . . . .',
     ];
-    expect(new Board(board).winner()).toEqual("");
+    expect(new Board(board).winner()).toEqual('');
   });
 
-  xtest("X can win on a 1x1 board", () => {
-    let board =  [
-      "X"
+  xtest('X can win on a 1x1 board', () => {
+    const board = [
+      'X',
     ];
-    expect(new Board(board).winner()).toEqual("X");
+    expect(new Board(board).winner()).toEqual('X');
   });
 
-  xtest("O can win on a 1x1 board", () => {
-    let board =  [
-      "O"
+  xtest('O can win on a 1x1 board', () => {
+    const board = [
+      'O',
     ];
-    expect(new Board(board).winner()).toEqual("O");
+    expect(new Board(board).winner()).toEqual('O');
   });
 
-  xtest( "only edges does not make a winner", () => {
-    let board =   [
-      "O O O X",
-      " X . . X",
-      "  X . . X",
-      "   X O O O"
+  xtest('only edges does not make a winner', () => {
+    const board = [
+      'O O O X',
+      ' X . . X',
+      '  X . . X',
+      '   X O O O',
     ];
-    expect(new Board(board).winner()).toEqual("");
+    expect(new Board(board).winner()).toEqual('');
   });
 
-  xtest("illegal diagonal does not make a winner", () => {
-    let board =  [
-      "X O . .",
-      " O X X X",
-      "  O X O .",
-      "   . O X .",
-      "    X X O O"
+  xtest('illegal diagonal does not make a winner', () => {
+    const board = [
+      'X O . .',
+      ' O X X X',
+      '  O X O .',
+      '   . O X .',
+      '    X X O O',
     ];
-    expect(new Board(board).winner()).toEqual("");
+    expect(new Board(board).winner()).toEqual('');
   });
 
-  xtest("nobody wins crossing adjacent angles", () => {
-    let board =  [
-      "X . . .",
-      " . X O .",
-      "  O . X O",
-      "   . O . X",
-      "    . . O ."
+  xtest('nobody wins crossing adjacent angles', () => {
+    const board = [
+      'X . . .',
+      ' . X O .',
+      '  O . X O',
+      '   . O . X',
+      '    . . O .',
     ];
-    expect(new Board(board).winner()).toEqual("");
+    expect(new Board(board).winner()).toEqual('');
   });
 
-  xtest("X wins crossing from left to right", () => {
-    let board =  [
-      ". O . .",
-      " O X X X",
-      "  O X O .",
-      "   X X O X",
-      "    . O X ."
+  xtest('X wins crossing from left to right', () => {
+    const board = [
+      '. O . .',
+      ' O X X X',
+      '  O X O .',
+      '   X X O X',
+      '    . O X .',
     ];
-    expect(new Board(board).winner()).toEqual("X");
+    expect(new Board(board).winner()).toEqual('X');
   });
 
-  xtest("O wins crossing from top to bottom", () => {
-    let board =  [
-      ". O . .",
-      " O X X X",
-      "  O O O .",
-      "   X X O X",
-      "    . O X ."
+  xtest('O wins crossing from top to bottom', () => {
+    const board = [
+      '. O . .',
+      ' O X X X',
+      '  O O O .',
+      '   X X O X',
+      '    . O X .',
     ];
-    expect(new Board(board).winner()).toEqual("O");
+    expect(new Board(board).winner()).toEqual('O');
   });
 
-  xtest("X wins using a convoluted path", () => {
-    let board =  [
-      ". X X . .",
-      " X . X . X",
-      "  . X . X .",
-      "   . X X . .",
-      "    O O O O O"
+  xtest('X wins using a convoluted path', () => {
+    const board = [
+      '. X X . .',
+      ' X . X . X',
+      '  . X . X .',
+      '   . X X . .',
+      '    O O O O O',
     ];
-    expect(new Board(board).winner()).toEqual("X");
+    expect(new Board(board).winner()).toEqual('X');
   });
 
-  xtest("X wins using a spiral path", () => {
-    let board =   [
-      "O X X X X X X X X",
-      " O X O O O O O O O",
-      "  O X O X X X X X O",
-      "   O X O X O O O X O",
-      "    O X O X X X O X O",
-      "     O X O O O X O X O",
-      "      O X X X X X O X O",
-      "       O O O O O O O X O",
-      "        X X X X X X X X O"
+  xtest('X wins using a spiral path', () => {
+    const board = [
+      'O X X X X X X X X',
+      ' O X O O O O O O O',
+      '  O X O X X X X X O',
+      '   O X O X O O O X O',
+      '    O X O X X X O X O',
+      '     O X O O O X O X O',
+      '      O X X X X X O X O',
+      '       O O O O O O O X O',
+      '        X X X X X X X X O',
     ];
-    expect(new Board(board).winner()).toEqual("X");
+    expect(new Board(board).winner()).toEqual('X');
   });
-
 });

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

@@ -4,67 +4,65 @@
  */
 export default class {
   constructor(board) {
-    this.board = board.map((b) => [...b]);
+    this.board = board.map(b => [...b]);
   }
   winner() {
-    const players = ['X','O'];
-    for(let player of players) {
-      if(this.checkWin(player)) {
+    const players = ['X', 'O'];
+    for (const player of players) {
+      if (this.checkWin(player)) {
         return player;
       }
     }
-    return "";
+    return '';
   }
   checkWin(player) {
-    let positions = this.startPositions(player);
-    for(let position of positions) {
-      if(this.search(position, player,[])) {
+    const positions = this.startPositions(player);
+    for (const position of positions) {
+      if (this.search(position, player, [])) {
         return true;
       }
     }
     return false;
   }
   search(pos, XorO, checked) {
-    if(! this.matches(pos, XorO)) {
+    if (!this.matches(pos, XorO)) {
       return false;
     }
-    if(this.winningSpot(pos, XorO)) {
+    if (this.winningSpot(pos, XorO)) {
       return true;
     }
     checked = checked.slice(0);
     checked.push(pos);
-    const matches = this.neighbors(pos).filter(({x,y}) => {
-      return this.matches({x,y}, XorO) && checked.filter((spot) => spot.x === x && spot.y === y).length === 0;
-    });
-    if(matches.length === 0) {
-     return false;
+    const matches = this.neighbors(pos).filter(({ x, y }) => this.matches({ x, y }, XorO) && checked.filter(spot => spot.x === x && spot.y === y).length === 0);
+    if (matches.length === 0) {
+      return false;
     }
 
     return matches.filter(spot => this.search(spot, XorO, checked)).length > 0;
   }
-  neighbors({x,y}) {
+  neighbors({ x, y }) {
     return [
-      {x, y: y + 2},
-      {x, y: y - 2},
+      { x, y: y + 2 },
+      { x, y: y - 2 },
 
-      {x: x + 1, y: y + 1},
-      {x: x - 1, y: y + 1},
+      { x: x + 1, y: y + 1 },
+      { x: x - 1, y: y + 1 },
 
-      {x: x + 1, y: y - 1},
-      {x: x - 1, y: y - 1}
+      { x: x + 1, y: y - 1 },
+      { x: x - 1, y: y - 1 },
     ];
   }
   startPositions(XorO) {
-    return XorO === "X" ?
-      this.board.map((pos, i) => ({x:i,y:i})) :
-      this.board[0].map((pos, i) => ({x:0, y:i}));
+    return XorO === 'X' ?
+      this.board.map((pos, i) => ({ x: i, y: i })) :
+      this.board[0].map((pos, i) => ({ x: 0, y: i }));
   }
-  winningSpot({x,y},XorO) {
-    return XorO === "X" ?
-      y === this.board[0].length - 1 + x:
+  winningSpot({ x, y }, XorO) {
+    return XorO === 'X' ?
+      y === this.board[0].length - 1 + x :
       x === this.board.length - 1;
   }
-  matches({x,y}, XorO) {
+  matches({ x, y }, XorO) {
     return this.board[x] !== undefined && this.board[x][y] === XorO;
   }
 }

data/tracks/ecmascript/exercises/crypto-square/crypto-square.spec.js

@@ -1,52 +1,52 @@
 import Crypto from './crypto-square';
 
-describe('Crypto',() => {
-  test('normalize strange characters',() => {
+describe('Crypto', () => {
+  test('normalize strange characters', () => {
     const crypto = new Crypto('s#$%^&plunk');
     expect(crypto.normalizePlaintext()).toEqual('splunk');
   });
 
-  xtest('normalize numbers',() => {
+  xtest('normalize numbers', () => {
     const crypto = new Crypto('1, 2, 3 GO!');
     expect(crypto.normalizePlaintext()).toEqual('123go');
   });
 
-  xtest('size of small square',() => {
+  xtest('size of small square', () => {
     const crypto = new Crypto('1234');
     expect(crypto.size()).toEqual(2);
   });
 
-  xtest('size of small square with additional non-number chars',() => {
+  xtest('size of small square with additional non-number chars', () => {
     const crypto = new Crypto('1 2 3 4');
     expect(crypto.size()).toEqual(2);
   });
 
-  xtest('size of slightly larger square',() => {
+  xtest('size of slightly larger square', () => {
     const crypto = new Crypto('123456789');
     expect(crypto.size()).toEqual(3);
   });
 
-  xtest('size of non-perfect square',() => {
+  xtest('size of non-perfect square', () => {
     const crypto = new Crypto('123456789abc');
     expect(crypto.size()).toEqual(4);
   });
 
-  xtest('plain text segments',() => {
+  xtest('plain text segments', () => {
     const crypto = new Crypto('Never vex thine heart with idle woes');
     expect(crypto.plaintextSegments()).toEqual(['neverv', 'exthin', 'eheart', 'withid', 'lewoes']);
   });
 
-  xtest('plain text segments',() => {
+  xtest('plain text segments', () => {
     const crypto = new Crypto('ZOMG! ZOMBIES!!!');
     expect(crypto.plaintextSegments()).toEqual(['zomg', 'zomb', 'ies']);
   });
 
-  xtest('cipher text',() => {
+  xtest('cipher text', () => {
     const crypto = new Crypto('Time is an illusion. Lunchtime doubly so.');
     expect(crypto.ciphertext()).toEqual('tasneyinicdsmiohooelntuillibsuuml');
   });
 
-  xtest('cipher text',() => {
+  xtest('cipher text', () => {
     const crypto = new Crypto('We all know interspecies romance is weird.');
     expect(crypto.ciphertext()).toEqual('wneiaweoreneawssciliprerlneoidktcms');
   });

data/tracks/ecmascript/exercises/crypto-square/example.js

@@ -1,29 +1,30 @@
 export default class Square {
-  constructor (input) {
+  constructor(input) {
     this.input = input;
   }
 
-  normalizePlaintext () {
-    return this.input.toLowerCase().replace(/[^a-zA-Z0-9]/g,'');
+  normalizePlaintext() {
+    return this.input.toLowerCase().replace(/[^a-zA-Z0-9]/g, '');
   }
 
-  size () {
+  size() {
     const realLength = Math.sqrt(this.normalizePlaintext().length);
     return Math.ceil(realLength);
   }
 
-  plaintextSegments () {
+  plaintextSegments() {
     const plainText = this.normalizePlaintext();
     const chunkSize = this.size();
 
-    const splitRegex = new RegExp('.{1,' + chunkSize + '}','g');
+    const splitRegex = new RegExp(`.{1,${chunkSize}}`, 'g');
     return plainText.match(splitRegex);
   }
 
-  ciphertext () {
+  ciphertext() {
     const textSegments = this.plaintextSegments(),
       columns = [];
-    let i, j,
+    let i,
+      j,
       currentSegment,
       currentLetter;
 
@@ -47,9 +48,9 @@ export default class Square {
     return columns.join('');
   }
 
-  normalizeCiphertext () {
+  normalizeCiphertext() {
     const chunkSize = this.size();
-    const splitRegex = new RegExp('.{1,' + chunkSize + '}','g');
+    const splitRegex = new RegExp(`.{1,${chunkSize}}`, 'g');
     return this.ciphertext().match(splitRegex).join(' ');
   }
 }

data/tracks/ecmascript/exercises/custom-set/custom-set.spec.js

@@ -1,8 +1,7 @@
 import CustomSet from './custom-set';
 
 describe('CustomSet', () => {
-
-  test('can delete elements', () =>{
+  test('can delete elements', () => {
     const expected = new CustomSet([1, 3]);
     const actual = new CustomSet([3, 2, 1]).delete(2);
     expect(actual.eql(expected)).toBe(true);
@@ -12,7 +11,7 @@ describe('CustomSet', () => {
     expect(actual2.eql(expected2)).toBe(true);
   });
 
-  xtest('can check for difference', () =>{
+  xtest('can check for difference', () => {
     const expected = new CustomSet([1, 3]);
     const actual = new CustomSet([3, 2, 1]).difference(new CustomSet([2, 4]));
     expect(actual.eql(expected)).toBe(true);
@@ -113,5 +112,4 @@ describe('CustomSet', () => {
     const expected4 = new CustomSet();
     expect(actual4.eql(expected4)).toBe(true);
   });
-
 });

data/tracks/ecmascript/exercises/custom-set/example.js

@@ -38,7 +38,7 @@ export default class CustomSet {
   }
 
   toList() {
-    return Object.keys(this.data).map(el =>  +el);
+    return Object.keys(this.data).map(el => +el);
   }
 
   member(el) {