trackler 2.2.1.71 → 2.2.1.72

data/tracks/ecmascript/exercises/change/package.json

@@ -9,7 +9,7 @@
     "url": "https://github.com/exercism/xecmascript"
   },
   "devDependencies": {
-    "babel-jest": "^20.0.3",
+    "babel-jest": "^21.2.0",
     "babel-plugin-transform-builtin-extend": "^1.1.2",
     "babel-preset-env": "^1.4.0",
     "eslint": "^3.19.0",
@@ -17,7 +17,7 @@
     "eslint-plugin-import": "^2.2.0",
     "eslint-plugin-jsx-a11y": "^5.0.1",
     "eslint-plugin-react": "^7.0.1",
-    "jest": "^20.0.4"
+    "jest": "^21.2.1"
   },
   "jest": {
     "modulePathIgnorePatterns": [
@@ -37,7 +37,9 @@
           ]
         }
       ],
-      ["transform-regenerator"]
+      [
+        "transform-regenerator"
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/protein-translation/package.json

@@ -9,7 +9,7 @@
     "url": "https://github.com/exercism/xecmascript"
   },
   "devDependencies": {
-    "babel-jest": "^20.0.3",
+    "babel-jest": "^21.2.0",
     "babel-plugin-transform-builtin-extend": "^1.1.2",
     "babel-preset-env": "^1.4.0",
     "eslint": "^3.19.0",
@@ -17,7 +17,7 @@
     "eslint-plugin-import": "^2.2.0",
     "eslint-plugin-jsx-a11y": "^5.0.1",
     "eslint-plugin-react": "^7.0.1",
-    "jest": "^20.0.4"
+    "jest": "^21.2.1"
   },
   "jest": {
     "modulePathIgnorePatterns": [

data/tracks/ecmascript/exercises/react/README.md

@@ -0,0 +1,41 @@
+# React
+
+Implement a basic reactive system.
+
+Reactive programming is a programming paradigm that focuses on how values
+are computed in terms of each other to allow a change to one value to
+automatically propagate to other values, like in a spreadsheet.
+
+Implement a basic reactive system with cells with settable values ("input"
+cells) and cells with values computed in terms of other cells ("compute"
+cells). Implement updates so that when an input value is changed, values
+propagate to reach a new stable system state.
+
+In addition, compute cells should allow for registering change notification
+callbacks.  Call a cell’s callbacks when the cell’s value in a new stable
+state has changed from the previous stable state.
+
+## Setup
+
+Go through the setup instructions for ECMAScript to
+install the necessary dependencies:
+
+http://exercism.io/languages/ecmascript/installation
+
+## Requirements
+
+Install assignment dependencies:
+
+```bash
+$ npm install
+```
+
+## Making the test suite pass
+
+Execute the tests with:
+
+```bash
+$ npm test
+```
+
+In the test suites all tests but the first have been skipped.

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

@@ -0,0 +1,101 @@
+class InputCell {
+  constructor(value) {
+    this.value = value;
+    this.updated = true;
+    this.subscribers = [];
+  }
+
+  setValue(value) {
+    if (value !== this.value) {
+      this.value = value;
+      this.notify();
+    }
+  }
+
+  notify() {
+    this.subscribers.forEach(sub => sub.markForUpdate());
+    this.subscribers.forEach(sub => sub.update());
+  }
+
+  addSubscriber(sub) {
+    this.subscribers.push(sub);
+  }
+}
+
+
+class ComputeCell {
+  constructor(inputCells, fn) {
+    this.fn = fn;
+    this.inputCells = inputCells;
+    this.inputCells.forEach(cell => cell.addSubscriber(this));
+    this.subscribers = [];
+    this.value = fn(inputCells);
+    this.callbacks = [];
+    this.updated = true;
+    this.lastValue = this.value;
+  }
+
+  update() {
+    let value = this.fn(this.inputCells);
+    if (value !== this.value) {
+      this.value = value;
+      this.updated = true;
+      this.notify();
+    }
+  }
+
+  notify() {
+    this.subscribers.forEach(sub => sub.markForUpdate());
+    this.subscribers.forEach(sub => sub.update());
+    this.runCallbacks();
+  }
+
+  markForUpdate() {
+    this.updated = false;
+    this.subscribers.forEach(sub => sub.markForUpdate());
+  }
+
+  runCallbacks() {
+    if (this.allInputsUpdated() && this.valueChanged()) {
+      this.lastValue = this.value;
+      this.callbacks.forEach(cb => cb.run(this));
+    }
+  }
+
+  allInputsUpdated() {
+    return this.inputCells
+      .filter(cell => cell.updated)
+      .length === this.inputCells.length;
+  }
+
+  valueChanged() {
+    return this.lastValue !== this.value;
+  }
+
+  addSubscriber(sub) {
+    this.subscribers.push(sub);
+  }
+
+  addCallback(cb) {
+    this.callbacks.push(cb);
+  }
+
+  removeCallback(cb) {
+    this.callbacks = this.callbacks.filter(c => c !== cb);
+  }
+}
+
+
+class CallbackCell {
+  constructor(fn) {
+    this.fn = fn;
+    this.values = [];
+  }
+
+  run(cell) {
+    this.values.push(this.fn(cell));
+  }
+}
+
+
+export {InputCell, ComputeCell, CallbackCell}

data/tracks/ecmascript/exercises/react/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "xecmascript",
+  "version": "0.0.0",
+  "description": "Exercism exercises in ECMAScript 6.",
+  "author": "Katrina Owen",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/xecmascript"
+  },
+  "devDependencies": {
+    "babel-jest": "^21.2.0",
+    "babel-plugin-transform-builtin-extend": "^1.1.2",
+    "babel-preset-env": "^1.4.0",
+    "eslint": "^3.19.0",
+    "eslint-config-airbnb": "^15.0.1",
+    "eslint-plugin-import": "^2.2.0",
+    "eslint-plugin-jsx-a11y": "^5.0.1",
+    "eslint-plugin-react": "^7.0.1",
+    "jest": "^21.2.1"
+  },
+  "jest": {
+    "modulePathIgnorePatterns": [
+      "package.json"
+    ]
+  },
+  "babel": {
+    "presets": [
+      "env"
+    ],
+    "plugins": [
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ],
+      [
+        "transform-regenerator"
+      ]
+    ]
+  },
+  "scripts": {
+    "test": "jest --no-cache ./*",
+    "watch": "jest --no-cache --watch ./*",
+    "lint": "eslint .",
+    "lint-test": "eslint . && jest --no-cache ./* "
+  },
+  "eslintConfig": {
+    "parserOptions": {
+      "ecmaVersion": 6,
+      "sourceType": "module"
+    },
+    "env": {
+      "es6": true,
+      "node": true,
+      "jest": true
+    },
+    "extends": "airbnb",
+    "rules": {
+      "import/no-unresolved": "off",
+      "import/extensions": "off"
+    }
+  },
+  "licenses": [
+    "MIT"
+  ],
+  "dependencies": {}
+}

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

@@ -0,0 +1,211 @@
+import {InputCell, ComputeCell, CallbackCell} from './react';
+
+describe('React module', () => {
+
+  test('accepts input', () => {
+    const inputCell = new InputCell(10);
+    expect(inputCell.value).toEqual(10);
+  });
+
+  xtest('allows input cell value to be set', () => {
+    const inputCell = new InputCell(4);
+    inputCell.setValue(20);
+    expect(inputCell.value).toEqual(20);
+  });
+
+  xtest('allows setting compute cells', () => {
+    const inputCell = new InputCell(1);
+    const fn = inputCells => inputCells[0].value + 1;
+    const computeCell = new ComputeCell([inputCell], fn);
+    expect(computeCell.value).toEqual(2);
+  });
+
+  xtest('compute cell takes inputs in correct order', () => {
+    const inputCells = [
+      new InputCell(1),
+      new InputCell(2)
+    ];
+
+    const computeCell = new ComputeCell(
+      inputCells,
+      inputs => inputs[0].value + inputs[1].value * 10
+    );
+
+    expect(computeCell.value).toEqual(21);
+  });
+
+  xtest('compute cells update value when inputs are changed', () => {
+    const inputCell = new InputCell(1);
+    const computeCell = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value + 1
+    );
+    inputCell.setValue(3);
+    expect(computeCell.value).toEqual(4);
+  });
+
+
+  xtest('compute cells can depend on other compute cells', () => {
+    const inputCell = new InputCell(1);
+    const timesTwo = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value * 2
+    );
+
+    const timesThirty = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value * 30
+    );
+
+    const sum = new ComputeCell(
+      [timesTwo, timesThirty],
+      inputs => inputs[0].value + inputs[1].value
+    );
+
+    expect(sum.value).toEqual(32);
+
+    inputCell.setValue(3);
+    expect(sum.value).toEqual(96);
+  });
+
+  xtest('compute cells fire callbacks', () => {
+    const inputCell = new InputCell(1);
+    const output = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value + 1
+    );
+
+    const callback = new CallbackCell(cell => cell.value);
+    output.addCallback(callback);
+
+    inputCell.setValue(3);
+    expect(callback.values).toEqual([4]);
+  });
+
+  xtest('callbacks fire only when output values change', () => {
+    const inputCell = new InputCell(1);
+    const output = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value < 3 ? 111 : 222
+    );
+
+    const callback = new CallbackCell(cell => cell.value);
+    output.addCallback(callback);
+
+    inputCell.setValue(2);
+    expect(callback.values).toEqual([]);
+
+    inputCell.setValue(4);
+    expect(callback.values).toEqual([222]);
+  });
+
+
+  xtest('callbacks can be added and removed', () => {
+    const inputCell = new InputCell(1);
+    const output = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value + 1
+    );
+
+    const callback1 = new CallbackCell(cell => cell.value);
+    const callback2 = new CallbackCell(cell => cell.value);
+
+    output.addCallback(callback1);
+    output.addCallback(callback2);
+
+    inputCell.setValue(31);
+
+    output.removeCallback(callback1);
+
+    const callback3 = new CallbackCell(cell => cell.value);
+    output.addCallback(callback3);
+
+    inputCell.setValue(41);
+
+    expect(callback1.values).toEqual([32]);
+    expect(callback2.values).toEqual([32, 42]);
+    expect(callback3.values).toEqual([42]);
+  });
+
+  xtest('removing a callback multiple times doesn\'t interfere with other callbacks', () => {
+    const inputCell = new InputCell(1);
+    const output = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value + 1
+    );
+
+    const callback1 = new CallbackCell(cell => cell.value);
+    const callback2 = new CallbackCell(cell => cell.value);
+
+    output.addCallback(callback1);
+    output.addCallback(callback2);
+
+    output.removeCallback(callback1);
+    output.removeCallback(callback1);
+    output.removeCallback(callback1);
+
+    inputCell.setValue(2);
+
+    expect(callback1.values).toEqual([]);
+    expect(callback2.values).toEqual([3]);
+  });
+
+  xtest('callbacks should only be called once, even if multiple dependencies change', () => {
+    const inputCell = new InputCell(1);
+    const plusOne = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value + 1
+    );
+
+    const minusOne1 = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value - 1
+    );
+
+    const minusOne2 = new ComputeCell(
+      [minusOne1],
+      inputs => inputs[0].value - 1
+    );
+
+    const output = new ComputeCell(
+      [plusOne, minusOne2],
+      inputs => inputs[0].value * inputs[1].value
+    );
+
+    const callback1 = new CallbackCell(cell => cell.value);
+    output.addCallback(callback1);
+
+    inputCell.setValue(4);
+
+    expect(callback1.values).toEqual([10]);
+  });
+
+  xtest('callbacks should not be called if dependencies change but output value doesn\'t change', () => {
+    const inputCell = new InputCell(1);
+    const plusOne = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value + 1
+    );
+
+    const minusOne = new ComputeCell(
+      [inputCell],
+      inputs => inputs[0].value - 1
+    );
+
+    const alwaysTwo = new ComputeCell(
+      [plusOne, minusOne],
+      inputs => inputs[0].value - inputs[1].value
+    );
+
+
+    const callback = new CallbackCell(cell => cell.value);
+    alwaysTwo.addCallback(callback);
+
+    inputCell.setValue(2);
+    inputCell.setValue(3);
+    inputCell.setValue(4);
+    inputCell.setValue(5);
+
+    expect(callback.values).toEqual([]);
+  });
+});