Merge pull request #195 from atk/etl

new exercise: etl

Author: atk

config.json

@@ -95,6 +95,14 @@
         "prerequisites": [],
         "difficulty": 2
       },
+      {
+        "slug": "etl",
+        "name": "ETL",
+        "uuid": "73c35d68-55b8-4615-bce8-49c7defc0181",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 2
+      },
       {
         "slug": "hamming",
         "name": "Hamming",

exercises/practice/etl/.docs/instructions.md

@@ -0,0 +1,27 @@
+# Instructions
+
+Your task is to change the data format of letters and their point values in the game.
+
+Currently, letters are stored in groups based on their score, in a one-to-many mapping.
+
+- 1 point: "A", "E", "I", "O", "U", "L", "N", "R", "S", "T",
+- 2 points: "D", "G",
+- 3 points: "B", "C", "M", "P",
+- 4 points: "F", "H", "V", "W", "Y",
+- 5 points: "K",
+- 8 points: "J", "X",
+- 10 points: "Q", "Z",
+
+This needs to be changed to store each individual letter with its score in a one-to-one mapping.
+
+- "a" is worth 1 point.
+- "b" is worth 3 points.
+- "c" is worth 3 points.
+- "d" is worth 2 points.
+- etc.
+
+As part of this change, the team has also decided to change the letters to be lower-case rather than upper-case.
+
+~~~~exercism/note
+If you want to look at how the data was previously structured and how it needs to change, take a look at the examples in the test suite.
+~~~~

exercises/practice/etl/.docs/introduction.md

@@ -0,0 +1,16 @@
+# Introduction
+
+You work for a company that makes an online multiplayer game called Lexiconia.
+
+To play the game, each player is given 13 letters, which they must rearrange to create words.
+Different letters have different point values, since it's easier to create words with some letters than others.
+
+The game was originally launched in English, but it is very popular, and now the company wants to expand to other languages as well.
+
+Different languages need to support different point values for letters.
+The point values are determined by how often letters are used, compared to other letters in that language.
+
+For example, the letter 'C' is quite common in English, and is only worth 3 points.
+But in Norwegian it's a very rare letter, and is worth 10 points.
+
+To make it easier to add new languages, your team needs to change the way letters and their point values are stored in the game.

exercises/practice/etl/.eslintrc

@@ -0,0 +1,14 @@
+{
+  "root": true,
+  "extends": "@exercism/eslint-config-javascript",
+  "env": {
+    "jest": true
+  },
+  "overrides": [
+    {
+      "files": ["*.spec.js"],
+      "excludedFiles": ["custom.spec.js"],
+      "extends": "@exercism/eslint-config-javascript/maintainers"
+    }
+  ]
+}

exercises/practice/etl/.meta/config.json

@@ -0,0 +1,28 @@
+{
+  "authors": [
+    "atk"
+  ],
+  "files": {
+    "solution": [
+      "etl.wat"
+    ],
+    "test": [
+      "etl.spec.js"
+    ],
+    "example": [
+      ".meta/proof.ci.wat"
+    ],
+    "invalidator": [
+      "package.json"
+    ]
+  },
+  "blurb": "Change the data format for scoring a game to more easily add other languages.",
+  "source": "Based on an exercise by the JumpstartLab team for students at The Turing School of Software and Design.",
+  "source_url": "https://turing.edu",
+  "custom": {
+    "version.tests.compatibility": "jest-27",
+    "flag.tests.task-per-describe": false,
+    "flag.tests.may-run-long": false,
+    "flag.tests.includes-optional": false
+  }
+}

exercises/practice/etl/.meta/proof.ci.wat

@@ -0,0 +1,67 @@
+(module
+  (memory (export "mem") 1)
+
+  (global $outputOffset i32 (i32.const 512))
+  (global $zero i32 (i32.const 48))
+  (global $nine i32 (i32.const 57))
+  (global $A i32 (i32.const 65))
+  (global $Z i32 (i32.const 90))
+  (global $lower i32 (i32.const 32))
+  (global $start i32 (i32.const 123))
+  (global $stop i32 (i32.const 125))
+  (global $reset i32 (i32.const 93))
+  (global $equals i32 (i32.const 58))
+  (global $quot i32 (i32.const 34))
+  (global $delim i32 (i32.const 44))
+
+  ;;
+  ;; Rewrite the incoming JSON to the new ETL format
+  ;;
+  ;; @param {i32} $inputOffset - offset of the JSON input in linear memory
+  ;; @param {i32} $inputLength - length of the JSON input in linear memory
+  ;;
+  ;; @returns {(i32,i32)} - offset and length of the JSON output in linear memory
+  ;;
+  (func (export "transform") (param $inputOffset i32) (param $inputLength i32) (result i32 i32)
+    (local $char i32)
+    (local $number i32)
+    (local $inputPos i32)
+    (local $outputLength i32)
+    (i32.store8 (global.get $outputOffset) (global.get $start))
+    (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))
+    (loop $chars
+      (local.set $char (i32.load8_u (i32.add (local.get $inputOffset) (local.get $inputPos))))
+      (if (i32.eq (local.get $char) (global.get $reset)) (then (local.set $number (i32.const 0))))
+      (if (i32.and (i32.ge_u (local.get $char) (global.get $zero))
+        (i32.le_u (local.get $char) (global.get $nine))) 
+          (then (local.set $number (i32.add (i32.mul (local.get $number) (i32.const 10))
+            (i32.sub (local.get $char) (global.get $zero))))))
+      (if (i32.and (i32.ge_u (local.get $char) (global.get $A))
+        (i32.le_u (local.get $char) (global.get $Z))) (then
+          (if (i32.gt_u (local.get $outputLength) (i32.const 1)) (then 
+            (i32.store8 (i32.add (global.get $outputOffset) (local.get $outputLength)) (global.get $delim))
+            (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))))
+          (i32.store8 (i32.add (global.get $outputOffset) (local.get $outputLength)) (global.get $quot))
+          (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))
+          (i32.store8 (i32.add (global.get $outputOffset) (local.get $outputLength))
+            (i32.or (local.get $char) (global.get $lower)))
+          (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))
+          (i32.store8 (i32.add (global.get $outputOffset) (local.get $outputLength)) (global.get $quot))
+          (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))
+          (i32.store8 (i32.add (global.get $outputOffset) (local.get $outputLength)) (global.get $equals))
+          (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))
+          (if (i32.ge_u (local.get $number) (i32.const 10)) (then
+            (i32.store8 (i32.add (global.get $outputOffset) (local.get $outputLength)) 
+              (i32.add (i32.div_u (local.get $number) (i32.const 10)) (global.get $zero)))
+            (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))))
+          (i32.store8 (i32.add (global.get $outputOffset) (local.get $outputLength)) 
+            (i32.add (i32.rem_u (local.get $number) (i32.const 10)) (global.get $zero)))
+          (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))
+        ))
+      (local.set $inputPos (i32.add (local.get $inputPos) (i32.const 1)))
+    (br_if $chars (i32.lt_u (local.get $inputPos) (local.get $inputLength))))
+    (i32.store8 (i32.add (global.get $outputOffset) (local.get $outputLength)) (global.get $stop))
+    (local.set $outputLength (i32.add (local.get $outputLength) (i32.const 1)))
+    (global.get $outputOffset) (local.get $outputLength)
+  )
+)

exercises/practice/etl/.meta/tests.toml

@@ -0,0 +1,22 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[78a7a9f9-4490-4a47-8ee9-5a38bb47d28f]
+description = "single letter"
+
+[60dbd000-451d-44c7-bdbb-97c73ac1f497]
+description = "single score with multiple letters"
+
+[f5c5de0c-301f-4fdd-a0e5-df97d4214f54]
+description = "multiple scores with multiple letters"
+
+[5db8ea89-ecb4-4dcd-902f-2b418cc87b9d]
+description = "multiple scores with differing numbers of letters"

exercises/practice/etl/.npmrc

@@ -0,0 +1 @@
+audit=false

exercises/practice/etl/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Exercism
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

exercises/practice/etl/babel.config.js

@@ -0,0 +1,4 @@
+export default {
+  presets: ["@exercism/babel-preset-javascript"],
+  plugins: [],
+};

exercises/practice/etl/etl.spec.js

@@ -0,0 +1,129 @@
+import { compileWat, WasmRunner } from "@exercism/wasm-lib";
+
+let wasmModule;
+let currentInstance;
+
+beforeAll(async () => {
+  try {
+    const watPath = new URL("./etl.wat", import.meta.url);
+    const { buffer } = await compileWat(watPath);
+    wasmModule = await WebAssembly.compile(buffer);
+  } catch (err) {
+    console.log(`Error compiling *.wat: \n${err}`);
+    process.exit(1);
+  }
+});
+
+
+const transform = (input) => {
+  const serializedInput = JSON.stringify(input);
+
+  const inputBufferOffset = 64;
+  const inputBufferCapacity = 256;
+
+  const inputLengthEncoded = new TextEncoder().encode(serializedInput).length;
+  if (inputLengthEncoded > inputBufferCapacity) {
+    throw new Error(
+      `String is too large for buffer of size ${inputBufferCapacity} bytes`
+    );
+  }
+
+  currentInstance.set_mem_as_utf8(inputBufferOffset, inputLengthEncoded, serializedInput);
+
+  const [outputOffset, outputLength] = currentInstance.exports.transform(
+    inputBufferOffset, inputLengthEncoded
+  );
+
+  const outputString = currentInstance.get_mem_as_utf8(outputOffset, outputLength);
+  return JSON.parse(outputString);
+}
+
+describe('Transform legacy to new', () => {
+  beforeEach(async () => {
+    currentInstance = null;
+    if (!wasmModule) {
+      return Promise.reject();
+    }
+    try {
+      currentInstance = await new WasmRunner(wasmModule);
+      return Promise.resolve();
+    } catch (err) {
+      console.log(`Error instantiating WebAssembly module: ${err}`);
+      return Promise.reject();
+    }
+  });
+
+  test('single letter', () => {
+    const old = { 1: ['A'] };
+    const expected = { a: 1 };
+
+    expect(transform(old)).toEqual(expected);
+  });
+
+  xtest('single score with multiple letters', () => {
+    const old = { 1: ['A', 'E', 'I', 'O', 'U'] };
+    const expected = {
+      a: 1,
+      e: 1,
+      i: 1,
+      o: 1,
+      u: 1,
+    };
+
+    expect(transform(old)).toEqual(expected);
+  });
+
+  xtest('multiple scores with multiple letters', () => {
+    const old = { 1: ['A', 'E'], 2: ['D', 'G'] };
+    const expected = {
+      a: 1,
+      e: 1,
+      d: 2,
+      g: 2,
+    };
+
+    expect(transform(old)).toEqual(expected);
+  });
+
+  xtest('multiple scores with differing numbers of letters', () => {
+    const old = {
+      1: ['A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T'],
+      2: ['D', 'G'],
+      3: ['B', 'C', 'M', 'P'],
+      4: ['F', 'H', 'V', 'W', 'Y'],
+      5: ['K'],
+      8: ['J', 'X'],
+      10: ['Q', 'Z'],
+    };
+    const expected = {
+      a: 1,
+      b: 3,
+      c: 3,
+      d: 2,
+      e: 1,
+      f: 4,
+      g: 2,
+      h: 4,
+      i: 1,
+      j: 8,
+      k: 5,
+      l: 1,
+      m: 3,
+      n: 1,
+      o: 1,
+      p: 3,
+      q: 10,
+      r: 1,
+      s: 1,
+      t: 1,
+      u: 1,
+      v: 4,
+      w: 4,
+      x: 8,
+      y: 4,
+      z: 10,
+    };
+
+    expect(transform(old)).toEqual(expected);
+  });
+});

exercises/practice/etl/etl.wat

@@ -0,0 +1,15 @@
+(module
+  (memory (export "mem") 1)
+
+  ;;
+  ;; Rewrite the incoming JSON to the new ETL format
+  ;;
+  ;; @param {i32} $inputOffset - offset of the JSON input in linear memory
+  ;; @param {i32} $inputLength - length of the JSON input in linear memory
+  ;;
+  ;; @returns {(i32,i32)} - offset and length of the JSON output in linear memory
+  ;;
+  (func (export "transform") (param $inputOffset i32) (param $inputLength i32) (result i32 i32)
+    (i32.const 0) (i32.const 0)
+  )
+)