trackler 2.2.1.178 → 2.2.1.179

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca50d7d1d4b2ee947e08370ff3fc95b678fc13d5
-  data.tar.gz: 1ab07f551bddfcefc505f1b1b0f03c3e0694d618
+  metadata.gz: de1658eb0260d4f09d4fa14ba3bbededefc02f33
+  data.tar.gz: 1c17f386b467a4ee630fd582ad8404c5582f138b
 SHA512:
-  metadata.gz: f04d0fce48e09d09e4666d18fcf1babc9968c33d242ee088c706400fd892b28728875ce4f9d0730540b72c4effa90b97a9e31f130ff39bc3fbf0839ad97eecf5
-  data.tar.gz: 7fc76eaac7b30187cde6435ac97632de98a38eec8c51913d93216c05771fac00c14c1af2fb87e6e33916266dc3d38cbdb33151e009ef0e0f59f21200d0acc47e
+  metadata.gz: b90a4be30889386c990d303e73e62ec5c7583027bc83bd885aeb60affa510c3af563b97dd3eb2fb290fbf7303ebfcbb1aed5c8907b0760e0cb47b7ca1c2d47af
+  data.tar.gz: 5ac571a21c860e43662578195809ab6b058f8bb32f8e5e395c629f3835c4ccc5f46b769cf6421e0b42438892f9b7ad473911cdc8bb8537acca0f2c7657a34ba4

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.178"
+  VERSION = "2.2.1.179"
 end

data/tracks/c/exercises/word-count/test/test_word_count.c

@@ -4,6 +4,8 @@
 #include "vendor/unity.h"
 #include "../src/word_count.h"
 
+#define STRING_SIZE (MAX_WORD_LENGTH + 1)
+
 word_count_word_t actual_solution[MAX_WORDS];
 word_count_word_t expected_solution[MAX_WORDS];
 void setUp(void)
@@ -27,8 +29,7 @@ static void check_solution(word_count_word_t * expected_solution,
       TEST_ASSERT_EQUAL(expected_solution[index].count,
                         actual_solution[index].count);
       TEST_ASSERT_EQUAL_UINT8_ARRAY(expected_solution[index].text,
-                                    actual_solution[index].text,
-                                    MAX_WORD_LENGTH);
+                                    actual_solution[index].text, STRING_SIZE);
    }
 }
 
@@ -45,7 +46,7 @@ void test_word_count_one_word(void)
 
    // fill in the expected words
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "word", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "word", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -66,13 +67,13 @@ void test_word_count_one_of_each_word(void)
 
    // fill in the expected words
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "one", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "one", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "of", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "of", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "each", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "each", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -92,19 +93,19 @@ void test_word_count_multiple_occurrences_of_a_word(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "one", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "one", STRING_SIZE);
 
    expected_solution[index].count = 4;
-   strncpy(expected_solution[index++].text, "fish", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "fish", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "two", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "two", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "red", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "red", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "blue", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "blue", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -124,13 +125,13 @@ void test_word_count_handles_cramped_lists(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "one", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "one", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "two", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "two", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "three", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "three", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -150,13 +151,13 @@ void test_word_count_handles_expanded_lists(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "one", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "one", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "two", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "two", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "three", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "three", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -176,19 +177,19 @@ void test_word_count_ignore_punctuation(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "car", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "car", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "carpet", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "carpet", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "as", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "as", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "java", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "java", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "javascript", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "javascript", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -208,13 +209,13 @@ void test_word_count_include_numbers(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 2;
-   strncpy(expected_solution[index++].text, "testing", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "testing", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "1", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "1", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "2", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "2", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -234,10 +235,10 @@ void test_word_count_normalize_case(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 3;
-   strncpy(expected_solution[index++].text, "go", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "go", STRING_SIZE);
 
    expected_solution[index].count = 2;
-   strncpy(expected_solution[index++].text, "stop", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "stop", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -257,19 +258,19 @@ void test_word_count_with_apostrophes(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "first", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "first", STRING_SIZE);
 
    expected_solution[index].count = 2;
-   strncpy(expected_solution[index++].text, "don't", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "don't", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "laugh", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "laugh", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "then", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "then", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "cry", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "cry", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -289,22 +290,22 @@ void test_word_count_with_quotation(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "joe", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "joe", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "can't", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "can't", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "tell", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "tell", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "between", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "between", STRING_SIZE);
 
    expected_solution[index].count = 2;
-   strncpy(expected_solution[index++].text, "large", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "large", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "and", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "and", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -324,16 +325,16 @@ void test_word_count_from_example(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 2;
-   strncpy(expected_solution[index++].text, "olly", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "olly", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "in", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "in", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "come", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "come", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "free", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "free", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -355,18 +356,17 @@ void test_max_length_word(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 2;
-   strncpy(expected_solution[index++].text, "look", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "look", STRING_SIZE);
 
    expected_solution[index].count = 2;
    strncpy(expected_solution[index++].text,
-           "thisisaveeeeeerylongwordtypedwithoutusinganyspaces",
-           MAX_WORD_LENGTH);
+           "thisisaveeeeeerylongwordtypedwithoutusinganyspaces", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "and", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "and", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "again", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "again", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -388,7 +388,7 @@ void test_excessive_length_word(void)
    // build the expected solution
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "look", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "look", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -410,64 +410,64 @@ void test_max_number_words(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "once", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "once", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "upon", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "upon", STRING_SIZE);
 
    expected_solution[index].count = 3;
-   strncpy(expected_solution[index++].text, "a", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "a", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "time", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "time", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "long", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "long", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "while", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "while", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "in", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "in", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "the", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "the", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "past", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "past", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "there", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "there", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "lived", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "lived", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "strange", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "strange", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "little", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "little", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "man", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "man", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "who", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "who", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "could", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "could", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "spin", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "spin", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "straw", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "straw", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "into", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "into", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "gold", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "gold", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 
@@ -489,64 +489,64 @@ void test_excessive_number_words(void)
    memset(expected_solution, 0, sizeof(expected_solution));     // clear to start with a known value
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "once", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "once", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "upon", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "upon", STRING_SIZE);
 
    expected_solution[index].count = 3;
-   strncpy(expected_solution[index++].text, "a", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "a", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "time", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "time", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "long", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "long", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "while", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "while", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "in", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "in", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "the", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "the", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "past", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "past", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "there", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "there", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "lived", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "lived", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "strange", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "strange", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "little", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "little", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "man", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "man", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "who", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "who", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "could", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "could", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "spin", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "spin", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "straw", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "straw", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "into", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "into", STRING_SIZE);
 
    expected_solution[index].count = 1;
-   strncpy(expected_solution[index++].text, "gold", MAX_WORD_LENGTH);
+   strncpy(expected_solution[index++].text, "gold", STRING_SIZE);
 
    actual_word_count = word_count(input_text, actual_solution);
 

data/tracks/delphi/config.json

@@ -17,7 +17,7 @@
     {
       "slug": "two-fer",
       "uuid": "60eb0882-495d-45f4-8d38-5b10d8851cf6",
-      "core": false,
+      "core": true,
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
@@ -201,6 +201,17 @@
         "text_formatting"
       ]
     },
+    {
+      "slug": "isogram",
+      "uuid": "7a489381-5ef6-49df-a05d-4c73b3ed9b53",
+      "core": false,
+      "unlocked_by": "two-fer",
+      "difficulty": 3,
+      "topics": [
+        "filtering",
+        "strings"
+      ]
+    },
     {
       "slug": "phone-number",
       "uuid": "cba5cf99-8001-4113-af80-cf9c041f1b21",

data/tracks/delphi/exercises/isogram/Isogram.dpr

@@ -0,0 +1,60 @@
+program Isogram;
+
+{$IFNDEF TESTINSIGHT}
+{$APPTYPE CONSOLE}
+{$ENDIF}{$STRONGLINKTYPES ON}
+uses
+  System.SysUtils,
+  {$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX,
+  {$ENDIF }
+  DUnitX.Loggers.Console,
+  DUnitX.Loggers.Xml.NUnit,
+  DUnitX.TestFramework,
+  uIsogramTests in 'uIsogramTests.pas',
+  uIsogram in 'uIsogram.pas';
+
+var
+  runner : ITestRunner;
+  results : IRunResults;
+  logger : ITestLogger;
+  nunitLogger : ITestLogger;
+begin
+{$IFDEF TESTINSIGHT}
+  TestInsight.DUnitX.RunRegisteredTests;
+  exit;
+{$ENDIF}
+  try
+    //Check command line options, will exit if invalid
+    TDUnitX.CheckCommandLine;
+    //Create the test runner
+    runner := TDUnitX.CreateRunner;
+    //Tell the runner to use RTTI to find Fixtures
+    runner.UseRTTI := True;
+    //tell the runner how we will log things
+    //Log to the console window
+    logger := TDUnitXConsoleLogger.Create(true);
+    runner.AddLogger(logger);
+    //Generate an NUnit compatible XML File
+    nunitLogger := TDUnitXXMLNUnitFileLogger.Create(TDUnitX.Options.XMLOutputFile);
+    runner.AddLogger(nunitLogger);
+    runner.FailsOnNoAsserts := False; //When true, Assertions must be made during tests;
+
+    //Run tests
+    results := runner.Execute;
+    if not results.AllPassed then
+      System.ExitCode := EXIT_ERRORS;
+
+    {$IFNDEF CI}
+    //We don't want this happening when running under CI.
+    if TDUnitX.Options.ExitBehavior = TDUnitXExitBehavior.Pause then
+    begin
+      System.Write('Done.. press <Enter> key to quit.');
+      System.Readln;
+    end;
+    {$ENDIF}
+  except
+    on E: Exception do
+      System.Writeln(E.ClassName, ': ', E.Message);
+  end;
+end.

data/tracks/delphi/exercises/isogram/README.md

@@ -0,0 +1,41 @@
+# Isogram
+
+Determine if a word or phrase is an isogram.
+
+An isogram (also known as a "nonpattern word") is a word or phrase without a repeating letter, however spaces and hyphens are allowed to appear multiple times.
+
+Examples of isograms:
+
+- lumberjacks
+- background
+- downstream
+- six-year-old
+
+The word *isograms*, however, is not an isogram, because the s repeats.
+
+## Testing
+
+In order to run the tests for this track, you will need to install
+DUnitX. Please see the [installation](http://www.exercism.io/languages/delphi/installation) instructions for more information.
+
+### Loading Exercises into Delphi
+
+If Delphi is properly installed, and `*.dpr` file types have been associated with Delphi, then double clicking the supplied `*.dpr` file will start Delphi and load the exercise/project.  `control + F9` is the keyboard shortcut to compile the project or pressing `F9` will compile and run the project.
+
+Alternatively you may opt to start Delphi and load your project via. the `File` drop down menu.
+
+### When Questions Come Up
+We monitor the [Pascal-Delphi](https://gitter.im/exercism/Pascal-Delphi) support room on [gitter.im](https://gitter.im) to help you with any questions that might arise.
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the exercise file you're submitting is in the `exercism/delphi/<exerciseName>` directory.
+
+For example, if you're submitting `ubob.pas` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/delphi/bob/ubob.pas`.
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Isogram](https://en.wikipedia.org/wiki/Isogram)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/delphi/exercises/isogram/uIsogramExample.pas

@@ -0,0 +1,34 @@
+unit uIsogram;
+
+interface
+uses
+  System.Generics.Collections;
+
+function isIsogram(aWords: string): Boolean;
+
+implementation
+uses SysUtils;
+
+function isIsogram(aWords: string): Boolean;
+var
+  Letters: TList<char>;
+  lChar: char;
+begin
+  Letters := TList<char>.Create;
+  try
+    aWords := aWords.ToLowerInvariant.Replace('-', '').Replace(' ','');
+    for lChar in aWords do
+    begin
+      if Letters.Contains(lChar) then
+        exit(false)
+      else
+        Letters.Add(lChar);
+    end;
+    result := true;
+  finally
+    Letters.Free;
+  end;
+end;
+
+end.
+

data/tracks/delphi/exercises/isogram/uIsogramTests.pas

@@ -0,0 +1,104 @@
+unit uIsogramTests;
+
+interface
+uses
+  DUnitX.TestFramework;
+
+const
+  CanonicalVersion = '1.3.0';
+
+type
+
+  [TestFixture]
+  IsogramTests = class(TObject)
+  public
+    [Test]
+//    [Ignore('Comment the "[Ignore]" statement to run the test')]
+    procedure empty_string;
+
+    [Test]
+    [Ignore]
+    procedure isogram_with_only_lower_case_characters;
+
+    [Test]
+    [Ignore]
+    procedure word_with_one_duplicated_character;
+
+    [Test]
+    [Ignore]
+    procedure longest_reported_english_isogram;
+
+    [Test]
+    [Ignore]
+    procedure word_with_duplicated_character_in_mixed_case;
+
+    [Test]
+    [Ignore]
+    procedure hypothetical_isogrammic_word_with_hyphen;
+
+    [Test]
+    [Ignore]
+    procedure isogram_with_duplicated_hyphen;
+
+    [Test]
+    [Ignore]
+    procedure made_up_name_that_is_an_isogram;
+
+    [Test]
+    [Ignore]
+    procedure duplicated_character_in_the_middle;
+  end;
+	
+implementation
+uses SysUtils, uIsogram;
+
+{ IsogramTests }
+
+procedure IsogramTests.duplicated_character_in_the_middle;
+begin
+  Assert.IsFalse(isIsogram('accentor'));
+end;
+
+procedure IsogramTests.empty_string;
+begin
+  Assert.IsTrue(isIsogram(''));
+end;
+
+procedure IsogramTests.hypothetical_isogrammic_word_with_hyphen;
+begin
+  Assert.IsTrue(isIsogram('thumbscrew-japingly'));
+end;
+
+procedure IsogramTests.isogram_with_duplicated_hyphen;
+begin
+  Assert.IsTrue(isIsogram('six-year-old'));
+end;
+
+procedure IsogramTests.isogram_with_only_lower_case_characters;
+begin
+  Assert.IsTrue(isIsogram('isogram'));
+end;
+
+procedure IsogramTests.longest_reported_english_isogram;
+begin
+  Assert.IsTrue(isIsogram('subdermatoglyphic'));
+end;
+
+procedure IsogramTests.made_up_name_that_is_an_isogram;
+begin
+  Assert.IsTrue(isIsogram('Emily Jung Schwartzkopf'));
+end;
+
+procedure IsogramTests.word_with_duplicated_character_in_mixed_case;
+begin
+  Assert.IsFalse(isIsogram('Alphabet'));
+end;
+
+procedure IsogramTests.word_with_one_duplicated_character;
+begin
+  Assert.IsFalse(isIsogram('eleven'));
+end;
+
+initialization
+  TDUnitX.RegisterTestFixture(IsogramTests);
+end.

data/tracks/elm/config.json

@@ -24,7 +24,7 @@
       "uuid": "50770287-c734-46ba-b3a1-c36d31b6cc3c",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 1,
+      "difficulty": 3,
       "topics": null
     },
     {

data/tracks/fsharp/exercises/matrix/Matrix.fs

@@ -2,4 +2,4 @@
 
 let row index matrix = failwith "You need to implement this function."
 
-let col index matrix = failwith "You need to implement this function."
+let column index matrix = failwith "You need to implement this function."

data/tracks/reasonml/Makefile

@@ -1,8 +1,10 @@
 EXERCISE ?= ""
-IGNOREDIRS := "^(\.git|docs|bin|node_modules|.idea)$$"
+IGNOREDIRS := "^(\.git|docs|bin|node_modules|.idea|.vscode)$$"
 EXERCISES = $(shell find ./exercises -maxdepth 1 -mindepth 1 -type d | cut -d'/' -f3 | sort | grep -Ev $(IGNOREDIRS))
 
-default: testgenerator test
+default: copy-all-exercises
+	npm run build
+	npm run test:ci
 
 # output directories
 OUTDIR ?= "tmp"

data/tracks/reasonml/README.md

@@ -9,19 +9,17 @@ Follow the instructions under https://reasonml.github.io/docs/en/quickstart-java
 
 ## Contributing
 
-Thank you so much for contributing! :tada:
+We welcome all contributions, both large and small.
 
 Please read about how to [get involved in a track](https://github.com/exercism/docs/tree/master/contributing-to-language-tracks). Be sure to read the Exercism [Code of Conduct](https://github.com/exercism/exercism.io/blob/master/CODE_OF_CONDUCT.md).
 
-We welcome pull requests of all kinds. No contribution is too small.
-
-We encourage contributions that provide fixes and improvements to existing exercises. Please note that this track's exercises must conform to the Exercism-wide standards described in the [documentation](https://github.com/exercism/docs/tree/master/language-tracks/exercises). If you're unsure about how to make a change, then go ahead and open a GitHub issue, and we'll discuss it.
+Fixes and improvements to existing exercises are welcome. Please note that this track's exercises must conform to the Exercism-wide standards described in the [documentation](https://github.com/exercism/docs/tree/master/language-tracks/exercises). If you're unsure about how to make a change, then go ahead and open a GitHub issue, and we'll discuss it.
 
 ## Exercise Tests
 
-At the most basic level, Exercism is all about the tests. You can read more about how we think about test suites in [the Exercism documentation](https://github.com/exercism/docs/blob/master/language-tracks/exercises/anatomy/test-suites.md).
+All Exercism exercises contain a test suite, which help to guide the user's implementation. You can read more about how we think about test suites in [the Exercism documentation](https://github.com/exercism/docs/blob/master/language-tracks/exercises/anatomy/test-suites.md).
 
-Test files should use the following format:
+Tests should be written using [bs-jest](https://github.com/glennsl/bs-jest).
 
 ```
 open Jest;
@@ -45,22 +43,17 @@ If you plan to make significant or breaking changes, please open an issue so we
 
 Pull requests should be focused on a single exercise, issue, or conceptually cohesive change. Please refer to Exercism's [pull request guidelines](https://github.com/exercism/docs/blob/master/contributing/pull-request-guidelines.md).
 
-Please follow the coding standards for ReasonML. (If there is a formatter for the track's language, add instructions for using it here.)
+Please use [refmt](https://reasonml.github.io/docs/en/extra-goodies.html) to ensure a consistent coding style.
+```
+refmt --in-place Example.re
+```
 
 ### Verifying Your Change
 
 Before submitting your pull request, you'll want to verify the changes in two ways:
 
-* Run all the tests for the ReasonML exercises
-* Run an Exercism-specific linter to verify the track
-
-All the tests for ReasonML exercises can be run from the top level of the repo with
-
-```
-# add this command
-```
-
-For the Exercism-specific linting, please see [the documentation](https://github.com/exercism/docs/blob/master/language-tracks/configuration/linting.md).
+* Run all the tests for the ReasonML exercises. There is a top level Makefile, run: ```make```.
+* Run checks on the repo using [configlet](https://github.com/exercism/docs/blob/master/language-tracks/configuration/configlet.md). From the top level, run: ```./bin/configlet lint --track-id reasonml .```
 
 ## Contributing a New Exercise
 

data/tracks/reasonml/config.json

@@ -81,104 +81,115 @@
       ]
     },
     {
-      "slug": "anagram",
-      "uuid": "1ddb534c-54e9-44a2-bd5f-fdcded7b03c8",
+      "slug": "raindrops",
+      "uuid": "d8ee28f4-bc35-408f-8380-a2eb54dec5b0",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 3,
+      "difficulty": 2,
       "topics": [
-        "filtering",
-        "strings"
+        "fun_expressions",
+        "list_map_function"
       ]
     },
     {
-      "slug": "raindrops",
-      "uuid": "d8ee28f4-bc35-408f-8380-a2eb54dec5b0",
+      "slug": "armstrong-numbers",
+      "uuid": "cc660762-4006-40c2-bc3b-a7bb4ac69202",
       "core": false,
       "unlocked_by": null,
       "difficulty": 2,
       "topics": [
-        "fun_expressions",
-        "list_map_function"
+        "arrays",
+        "folding",
+        "algorithms",
+        "mathematics"
       ]
     },
     {
-      "slug": "pangram",
-      "uuid": "dddf877a-a8d4-45d7-8543-882c08bad2e8",
+      "slug": "anagram",
+      "uuid": "1ddb534c-54e9-44a2-bd5f-fdcded7b03c8",
       "core": false,
       "unlocked_by": null,
       "difficulty": 3,
       "topics": [
+        "filtering",
         "strings"
       ]
     },
     {
-      "slug": "binary-search",
-      "uuid": "eb635d37-a70b-47b2-883b-8ec9ca6098ef",
+      "slug": "pangram",
+      "uuid": "dddf877a-a8d4-45d7-8543-882c08bad2e8",
       "core": false,
       "unlocked_by": null,
       "difficulty": 3,
       "topics": [
-        "arrays",
-        "recursion"
+        "strings"
       ]
     },
     {
-      "slug": "run-length-encoding",
-      "uuid": "1c8245de-3ae2-4b59-83a9-d34c540f67f0",
+      "slug": "isogram",
+      "uuid": "4e7e7b4b-b279-47c2-9d5a-3c44f7bbeb34",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 4,
+      "difficulty": 3,
       "topics": [
         "strings",
-        "converting_strings_to_ints"
+        "lists"
       ]
     },
     {
-      "slug": "change",
-      "uuid": "3526ae52-5962-43d6-ae83-dd6a9ca6e25b",
+      "slug": "phone-number",
+      "uuid": "2721c31b-773e-43c5-93ab-f704d62e5cde",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 5,
+      "difficulty": 3,
       "topics": [
-        "integers",
-        "recursion",
-        "dynamic_programming"
+        "strings",
+        "regular_expressions"
       ]
     },
     {
-      "slug": "phone-number",
-      "uuid": "2721c31b-773e-43c5-93ab-f704d62e5cde",
+      "slug": "roman-numerals",
+      "uuid": "fb891c45-82f1-422d-ac4e-00409668d6a7",
       "core": false,
       "unlocked_by": null,
       "difficulty": 3,
       "topics": [
         "strings",
-        "regular_expressions"
+        "arithmetic"
       ]
     },
     {
-      "slug": "armstrong-numbers",
-      "uuid": "cc660762-4006-40c2-bc3b-a7bb4ac69202",
+      "slug": "binary-search",
+      "uuid": "eb635d37-a70b-47b2-883b-8ec9ca6098ef",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 2,
+      "difficulty": 4,
       "topics": [
         "arrays",
-        "folding",
-        "algorithms",
-        "mathematics"
+        "recursion"
       ]
     },
     {
-      "slug": "isogram",
-      "uuid": "4e7e7b4b-b279-47c2-9d5a-3c44f7bbeb34",
+      "slug": "run-length-encoding",
+      "uuid": "1c8245de-3ae2-4b59-83a9-d34c540f67f0",
       "core": false,
       "unlocked_by": null,
-      "difficulty": 3,
+      "difficulty": 5,
       "topics": [
         "strings",
-        "lists"
+        "converting_strings_to_ints"
+      ]
+    },
+    {
+      "slug": "change",
+      "uuid": "3526ae52-5962-43d6-ae83-dd6a9ca6e25b",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 5,
+      "topics": [
+        "integers",
+        "recursion",
+        "dynamic_programming"
       ]
     }
   ]

data/tracks/reasonml/exercises/roman-numerals/README.md

@@ -0,0 +1,69 @@
+# Roman Numerals
+
+Write a function to convert from normal numbers to Roman Numerals.
+
+The Romans were a clever bunch. They conquered most of Europe and ruled
+it for hundreds of years. They invented concrete and straight roads and
+even bikinis. One thing they never discovered though was the number
+zero. This made writing and dating extensive histories of their exploits
+slightly more challenging, but the system of numbers they came up with
+is still in use today. For example the BBC uses Roman numerals to date
+their programmes.
+
+The Romans wrote numbers using letters - I, V, X, L, C, D, M. (notice
+these letters have lots of straight lines and are hence easy to hack
+into stone tablets).
+
+```text
+ 1  => I
+10  => X
+ 7  => VII
+```
+
+There is no need to be able to convert numbers larger than about 3000.
+(The Romans themselves didn't tend to go any higher)
+
+Wikipedia says: Modern Roman numerals ... are written by expressing each
+digit separately starting with the left most digit and skipping any
+digit with a value of zero.
+
+To see this in practice, consider the example of 1990.
+
+In Roman numerals 1990 is MCMXC:
+
+1000=M
+900=CM
+90=XC
+
+2008 is written as MMVIII:
+
+2000=MM
+8=VIII
+
+See also: http://www.novaroma.org/via_romana/numbers.html
+
+## Building and testing
+You will need the node package manager (npm) installed - download from [here](https://www.npmjs.com/get-npm)
+There is one time setup for each exercise, which may take a few minutes:
+```
+npm install
+```
+
+Open two shells, and in the first, start the build process.
+```
+npm start
+```
+
+In the second, start the tests running.
+```
+npm test
+```
+
+As you edit the code, the two processes will continually rebuild and rerun the tests.
+
+## Source
+
+The Roman Numeral Kata [http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals](http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/reasonml/exercises/roman-numerals/__tests__/RomanNumerals_test.re

@@ -0,0 +1,64 @@
+open Jest;
+open Expect;
+open RomanNumerals;
+
+describe("RomanNumerals", () => {
+  test("1 is a single I", () =>
+    expect(toRoman(1)) |> toEqual("I")
+  );
+  test("2 is two I's", () =>
+    expect(toRoman(2)) |> toEqual("II") 
+  );
+  test("3 is three I's", () =>
+    expect(toRoman(3)) |> toEqual("III") 
+  );
+  test("4, being 5 - 1, is IV", () =>
+    expect(toRoman(4)) |> toEqual("IV")
+  );
+  test("5 is a single V", () =>
+    expect(toRoman(5)) |> toEqual("V") 
+  );
+  test("6, being 5 + 1, is VI", () =>
+    expect(toRoman(6)) |> toEqual("VI") 
+  );
+  test("9, being 10 - 1, is IX", () =>
+    expect(toRoman(9)) |> toEqual("IX") 
+  );
+  test("20 is two X's", () =>
+    expect(toRoman(27)) |> toEqual("XXVII")
+  );
+  test("48 is not 50 - 2 but rather 40 + 8", () =>
+    expect(toRoman(48)) |> toEqual("XLVIII") 
+  );
+  test("49 is not 40 + 5 + 4 but rather 50 - 10 + 10 - 1", () =>
+    expect(toRoman(49)) |> toEqual("XLIX") 
+  );
+  test("50 is a single L", () =>
+    expect(toRoman(59)) |> toEqual("LIX") 
+  );
+  test("90, being 100 - 10, is XC", () =>
+    expect(toRoman(93)) |> toEqual("XCIII") 
+  );
+  test("100 is a single C", () =>
+    expect(toRoman(141)) |> toEqual("CXLI") 
+  );
+  test("60, being 50 + 10, is LX", () =>
+    expect(toRoman(163)) |> toEqual("CLXIII") 
+  );
+  test("400, being 500 - 100, is CD", () =>
+    expect(toRoman(402)) |> toEqual("CDII") 
+  );
+  test("500 is a single D", () =>
+    expect(toRoman(575)) |> toEqual("DLXXV") 
+  );
+  test("900, being 1000 - 100, is CM", () =>
+    expect(toRoman(911)) |> toEqual("CMXI")
+  );
+  test("1000 is a single M", () =>
+    expect(toRoman(1024)) |> toEqual("MXXIV")
+  );
+  test("3000 is three M's", () =>
+    expect(toRoman(3000)) |> toEqual("MMM")
+  );
+});
+

data/tracks/reasonml/exercises/roman-numerals/bsconfig.json

@@ -0,0 +1,30 @@
+// This is the configuration file used by BuckleScript's build system bsb. Its documentation lives here: http://bucklescript.github.io/bucklescript/docson/#build-schema.json
+// BuckleScript comes with its own parser for bsconfig.json, which is normal JSON, with the extra support of comments and trailing commas.
+{
+  "name": "roman-numerals",
+  "version": "0.1.0",
+  "sources": [
+    {
+      "dir" : "src",
+      "subdirs" : true
+    },
+    {
+      "dir": "__tests__",
+      "type": "dev"
+    }
+  ],
+  "package-specs": {
+    "module": "commonjs",
+    "in-source": true
+  },
+  "suffix": ".bs.js",
+  "bs-dependencies": [
+      // add your dependencies here. You'd usually install them normally through `npm install my-dependency`. If my-dependency has a bsconfig.json too, then everything will work seamlessly.
+  ],
+  "bs-dev-dependencies": ["@glennsl/bs-jest"],
+  "warnings": {
+    "error" : "+101"
+  },
+  "namespace": true,
+  "refmt": 3
+}

data/tracks/reasonml/exercises/roman-numerals/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "roman-numerals",
+  "version": "0.1.0",
+  "scripts": {
+    "build": "bsb -make-world",
+    "start": "bsb -make-world -w",
+    "clean": "bsb -clean-world",
+    "test": "jest --watchAll",
+    "test:ci": "jest --ci --bail --no-cache"
+  },
+  "keywords": [
+    "BuckleScript"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@glennsl/bs-jest": "^0.4.2",
+    "bs-platform": "^3.1.5"
+  }
+}

data/tracks/reasonml/exercises/roman-numerals/src/Example.re

@@ -0,0 +1,19 @@
+let toRoman = (n) => {
+  let rec go = (s) =>
+    fun
+    | n when n >= 1000 => go(s ++ "M", n - 1000)
+    | n when n >= 900 => go(s ++ "CM", n - 900)
+    | n when n >= 500 => go(s ++ "D", n - 500)
+    | n when n >= 400 => go(s ++ "CD", n - 400)
+    | n when n >= 100 => go(s ++ "C", n - 100)
+    | n when n >= 90 => go(s ++ "XC", n - 90)
+    | n when n >= 50 => go(s ++ "L", n - 50)
+    | n when n >= 40 => go(s ++ "XL", n - 40)
+    | n when n >= 10 => go(s ++ "X", n - 10)
+    | n when n == 9 => go(s ++ "IX", n - 9)
+    | n when n >= 5 => go(s ++ "V", n - 5)
+    | n when n == 4 => go(s ++ "IV", n - 4)
+    | n when n >= 1 => go(s ++ "I", n - 1)
+    | _ => s;
+  go("", n);
+};

data/tracks/reasonml/exercises/roman-numerals/src/RomanNumerals.rei

@@ -0,0 +1 @@
+let toRoman: int => string;

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.178
+  version: 2.2.1.179
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-03 00:00:00.000000000 Z
+date: 2018-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -3666,6 +3666,10 @@ files:
 - tracks/delphi/exercises/isbn-verifier/README.md
 - tracks/delphi/exercises/isbn-verifier/uISBNVerifierExample.pas
 - tracks/delphi/exercises/isbn-verifier/uTestISBNVerifier.pas
+- tracks/delphi/exercises/isogram/Isogram.dpr
+- tracks/delphi/exercises/isogram/README.md
+- tracks/delphi/exercises/isogram/uIsogramExample.pas
+- tracks/delphi/exercises/isogram/uIsogramTests.pas
 - tracks/delphi/exercises/leap/Leap.dpr
 - tracks/delphi/exercises/leap/README.md
 - tracks/delphi/exercises/leap/uLeapExample.pas
@@ -12723,6 +12727,12 @@ files:
 - tracks/reasonml/exercises/rna-transcription/package.json
 - tracks/reasonml/exercises/rna-transcription/src/Example.re
 - tracks/reasonml/exercises/rna-transcription/src/RnaTranscription.rei
+- tracks/reasonml/exercises/roman-numerals/README.md
+- tracks/reasonml/exercises/roman-numerals/__tests__/RomanNumerals_test.re
+- tracks/reasonml/exercises/roman-numerals/bsconfig.json
+- tracks/reasonml/exercises/roman-numerals/package.json
+- tracks/reasonml/exercises/roman-numerals/src/Example.re
+- tracks/reasonml/exercises/roman-numerals/src/RomanNumerals.rei
 - tracks/reasonml/exercises/run-length-encoding/README.md
 - tracks/reasonml/exercises/run-length-encoding/__tests__/RunLengthEncoding_test.re
 - tracks/reasonml/exercises/run-length-encoding/bsconfig.json