feat: add isbn-verifier exercise

Author: vaeng

config.json

@@ -65,6 +65,14 @@
         "prerequisites": [],
         "difficulty": 1
       },
+      {
+        "slug": "isbn-verifier",
+        "name": "ISBN Verifier",
+        "uuid": "c4e3ea2f-8648-49ba-a9a5-54ba11b5c27e",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 3
+      },
       {
         "slug": "leap",
         "name": "Leap",

exercises/practice/isbn-verifier/.docs/instructions.md

@@ -0,0 +1,42 @@
+# Instructions
+
+The [ISBN-10 verification process][isbn-verification] is used to validate book identification numbers.
+These normally contain dashes and look like: `3-598-21508-8`
+
+## ISBN
+
+The ISBN-10 format is 9 digits (0 to 9) plus one check character (either a digit or an X only).
+In the case the check character is an X, this represents the value '10'.
+These may be communicated with or without hyphens, and can be checked for their validity by the following formula:
+
+```text
+(d₁ * 10 + d₂ * 9 + d₃ * 8 + d₄ * 7 + d₅ * 6 + d₆ * 5 + d₇ * 4 + d₈ * 3 + d₉ * 2 + d₁₀ * 1) mod 11 == 0
+```
+
+If the result is 0, then it is a valid ISBN-10, otherwise it is invalid.
+
+## Example
+
+Let's take the ISBN-10 `3-598-21508-8`.
+We plug it in to the formula, and get:
+
+```text
+(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 == 0
+```
+
+Since the result is 0, this proves that our ISBN is valid.
+
+## Task
+
+Given a string the program should check if the provided string is a valid ISBN-10.
+Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+
+The program should be able to verify ISBN-10 both with and without separating dashes.
+
+## Caveats
+
+Converting from strings to numbers can be tricky in certain languages.
+Now, it's even trickier since the check digit of an ISBN-10 may be 'X' (representing '10').
+For instance `3-598-21507-X` is a valid ISBN-10.
+
+[isbn-verification]: https://en.wikipedia.org/wiki/International_Standard_Book_Number

exercises/practice/isbn-verifier/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "vaeng"
+  ],
+  "files": {
+    "solution": [
+      "solution.jai"
+    ],
+    "test": [
+      "tests.jai"
+    ],
+    "example": [
+      ".meta/example.jai"
+    ]
+  },
+  "blurb": "Check if a given string is a valid ISBN-10 number.",
+  "source": "Converting a string into a number and some basic processing utilizing a relatable real world example.",
+  "source_url": "https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation"
+}

exercises/practice/isbn-verifier/.meta/example.jai

@@ -0,0 +1,18 @@
+is_valid :: (isbn: string) -> bool {
+    sum: int;
+    counter: int;
+    for isbn {
+        if it == #char "-" {
+            continue;
+        }
+        counter += 1;
+        if it == #char "X" && counter == 10 {
+            sum += 10;
+        } else if it >= #char "0" && it <= #char "9" {
+            sum += (it - #char "0") * (11 - counter);
+        } else {
+            return false;
+        }
+    }
+    return counter == 10 && sum % 11 == 0;
+}

exercises/practice/isbn-verifier/.meta/generator.jai

@@ -0,0 +1,14 @@
+to_test_case :: (canonical_case: CanonicalCase) -> Test {
+    _, isbn := get_property(canonical_case.input, "isbn");
+
+    return Test.{
+        name = to_test_name(canonical_case.description_path),
+        body = tprint("assert_equal(%, is_valid(%));", to_code(canonical_case.expected), to_code(isbn)),
+        skip = canonical_case.index > 0
+    };
+}
+
+#run run_generator("isbn-verifier", to_test_case);
+
+#import "Basic";
+#import,dir "../../../shared/generator";

exercises/practice/isbn-verifier/.meta/tests.toml

@@ -0,0 +1,73 @@
+# 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.
+
+[0caa3eac-d2e3-4c29-8df8-b188bc8c9292]
+description = "valid isbn"
+
+[19f76b53-7c24-45f8-87b8-4604d0ccd248]
+description = "invalid isbn check digit"
+
+[4164bfee-fb0a-4a1c-9f70-64c6a1903dcd]
+description = "valid isbn with a check digit of 10"
+
+[3ed50db1-8982-4423-a993-93174a20825c]
+description = "check digit is a character other than X"
+
+[9416f4a5-fe01-4b61-a07b-eb75892ef562]
+description = "invalid check digit in isbn is not treated as zero"
+
+[c19ba0c4-014f-4dc3-a63f-ff9aefc9b5ec]
+description = "invalid character in isbn is not treated as zero"
+
+[28025280-2c39-4092-9719-f3234b89c627]
+description = "X is only valid as a check digit"
+
+[8005b57f-f194-44ee-88d2-a77ac4142591]
+description = "only one check digit is allowed"
+
+[fdb14c99-4cf8-43c5-b06d-eb1638eff343]
+description = "X is not substituted by the value 10"
+
+[f6294e61-7e79-46b3-977b-f48789a4945b]
+description = "valid isbn without separating dashes"
+
+[185ab99b-3a1b-45f3-aeec-b80d80b07f0b]
+description = "isbn without separating dashes and X as check digit"
+
+[7725a837-ec8e-4528-a92a-d981dd8cf3e2]
+description = "isbn without check digit and dashes"
+
+[47e4dfba-9c20-46ed-9958-4d3190630bdf]
+description = "too long isbn and no dashes"
+
+[737f4e91-cbba-4175-95bf-ae630b41fb60]
+description = "too short isbn"
+
+[5458a128-a9b6-4ff8-8afb-674e74567cef]
+description = "isbn without check digit"
+
+[70b6ad83-d0a2-4ca7-a4d5-a9ab731800f7]
+description = "check digit of X should not be used for 0"
+
+[94610459-55ab-4c35-9b93-ff6ea1a8e562]
+description = "empty isbn"
+
+[7bff28d4-d770-48cc-80d6-b20b3a0fb46c]
+description = "input is 9 characters"
+
+[ed6e8d1b-382c-4081-8326-8b772c581fec]
+description = "invalid characters are not ignored after checking length"
+
+[daad3e58-ce00-4395-8a8e-e3eded1cdc86]
+description = "invalid characters are not ignored before checking length"
+
+[fb5e48d8-7c03-4bfb-a088-b101df16fdc3]
+description = "input is too long but contains a valid isbn"

exercises/practice/isbn-verifier/extest.jai

@@ -0,0 +1,200 @@
+// Jai, being a very young language, doesn't have a built-in testing framework.
+// This file provides basic testing functionality that can be used in exercises 
+// to run the tests and print a report of which tests passed and which failed.
+
+// This macro is used to compare the expected and actual values in a test.
+// It works on Code values for the expected and actual values, which allows it to capture 
+// the code of the test assertion for reporting purposes.
+assert_equal :: (expected: Code, actual: Code, call := #caller_code, loc := #caller_location) #expand {
+    // The test name is derived from the name of the test procedure, which is the caller of this macro.
+    test_name := #procedure_name();
+
+    // Convert the call to this macro into its original source code form for reporting purposes.
+    test_code_builder: String_Builder;
+    print_expression(*test_code_builder, compiler_get_nodes(call));
+    test_code := builder_to_string(*test_code_builder);
+
+    expected_value := #insert expected;
+    actual_value   := #insert actual;
+
+    if expected_value == actual_value {
+        set_test_result(test_name, .PASSED, "", test_code);
+    } else {
+        message := sprint("Expected: %, actual: %", expected_value, actual_value);
+        set_test_result(test_name, .FAILED, message, test_code);
+
+        // Short-circuit test execution to avoid cascading failures
+        `return;
+    }
+}
+
+// This macro allows skipping a test.
+// A skipped test's code will _not_ be executed.
+skip :: (code: Code) #expand {
+    // Do not skip the test if the '-run_skipped' build option was provided.
+    // This is used by the test runner to forcibly run _all_ tests, including skipped tests.
+    skip_test := !has_build_option("-run_skipped");
+
+    if skip_test {
+        // Get the name of the test procedure being skipped for reporting purposes
+        test_procedure_call := cast (*Code_Procedure_Call)compiler_get_nodes(code); 
+        test_procedure_identifier := cast (*Code_Ident)test_procedure_call.procedure_expression;
+        test_name := test_procedure_identifier.name;
+        set_test_result(test_name, .SKIPPED, "", "");
+         
+        // As we're skipping the test, we don't insert the original test procedure call, which prevents
+        // the test from being executed
+    } else {
+        // Don't skip the test, so insert the original test procedure call to execute the test as normal.
+        #insert code;
+    }
+}
+
+set_test_result :: inline (test_name: string, status: TestStatus, message: string, test_code: string) {
+    test: TestResult = .{test_name, status, message, test_code};
+
+    // If there already is a test result for this test name, it means the test has multiple assertions.
+    // As we short-circuit test execution on failure, the existing test result _must_ be a passing test,
+    // so we can safely overwrite the existing test result
+    if context.test_run.tests.count > 0 && context.test_run.tests[context.test_run.tests.count - 1].name == test_name {
+        context.test_run.tests[context.test_run.tests.count - 1] = test;
+    } else {
+        array_add(*context.test_run.tests, test);
+    }
+
+    // If we have one failing test, the whole test run is considered failed
+    if status == .FAILED  context.test_run.status = .FAILED;
+}
+
+before_running_tests :: () {
+    set_build_options_dc(.{do_output=false});
+    context.started_at = current_time_monotonic();
+}
+
+after_running_tests :: () {
+    if has_build_option("-json") {
+        write_json_test_report();
+    } else {
+        print_test_report();
+    }
+
+    if context.test_run.status == .FAILED {
+        exit(1);
+    } else {
+        exit(0);
+    }
+}
+
+// Print the test results in the Exercism Test Runner output format:
+// https://exercism.org/docs/building/tooling/test-runners/interface#h-output-format
+write_json_test_report :: () {
+    // As there is no built-in JSON support in Jai, we manually build a JSON string.
+    json_builder: String_Builder;
+    init_string_builder(*json_builder);
+
+    append(*json_builder, "{\n");
+    append(*json_builder, "  \"version\": 2,\n");
+    append(*json_builder, tprint("  \"status\": \"%\",\n", test_status_to_string(context.test_run.status)));
+    append(*json_builder, "  \"tests\": [\n");
+
+    for context.test_run.tests {
+        append(*json_builder, "    {\n");
+        append(*json_builder, tprint("      \"name\": \"%\",\n", json_escape_string(it.name)));
+        append(*json_builder, tprint("      \"status\": \"%\",\n", test_status_to_string(it.status)));
+        if it.message.count > 0 {
+            append(*json_builder, tprint("      \"message\": \"%\",\n", json_escape_string(it.message)));
+        }
+        append(*json_builder, tprint("      \"test_code\": \"%\"\n", json_escape_string(it.test_code)));
+        append(*json_builder, "    }");
+        if it_index < context.test_run.tests.count - 1 {
+            append(*json_builder, ",");
+        }
+        append(*json_builder, "\n");
+    }
+
+    append(*json_builder, "  ]\n");
+    append(*json_builder, "}\n");
+
+    json := builder_to_string(*json_builder);
+    write_entire_file("results.json", json);
+}
+
+json_escape_string :: (str: string) -> string {
+    escaped_builder: String_Builder;
+    init_string_builder(*escaped_builder);
+
+    for str {
+        if it == {
+            case #char "\""; append(*escaped_builder, "\\\"");
+            case #char "\\"; append(*escaped_builder, "\\\\");
+            case #char "\n"; append(*escaped_builder, "\\n");
+            case #char "\r"; append(*escaped_builder, "\\r");
+            case #char "\t"; append(*escaped_builder, "\\t");
+            case; append(*escaped_builder, it);
+        }
+    }
+    return builder_to_string(*escaped_builder);
+}
+
+test_status_to_string :: inline (status: TestStatus) -> string {
+    if status == {
+        case .PASSED;
+            return "pass";
+        case .FAILED;
+            return "fail";
+        case .SKIPPED;
+            return "skip";
+        case;
+            return "error";
+    };
+}
+
+print_test_report :: () {
+    failed_tests, passed_tests, skipped_tests := 0;
+    duration := to_float64_seconds(current_time_monotonic() - context.started_at);
+
+    for test: context.test_run.tests {
+        if test.status == {
+            case .PASSED;
+                passed_tests += 1;
+            case .FAILED;
+                failed_tests += 1;
+                print("Test '%' failed.\n  %\n", test.name, test.message);
+            case .SKIPPED;
+                skipped_tests += 1;
+        }
+    }
+    print("Test summary: total: %, failed: %, succeeded: %, skipped: %, duration: % seconds\n", failed_tests + passed_tests + skipped_tests, failed_tests, passed_tests, skipped_tests, duration);
+}
+
+has_build_option :: inline (arg: string) -> bool {
+    for get_build_options().compile_time_command_line  if it == arg  return true;
+    return false;
+}
+
+TestStatus :: enum u8 {
+    PASSED;
+    FAILED;
+    SKIPPED;
+}
+
+TestResult :: struct {
+    name: string;
+    status: TestStatus;
+    message: string;
+    test_code: string;
+};
+
+TestRun :: struct {
+    version := 2;
+    status := TestStatus.PASSED;
+    tests: [..] TestResult;
+};
+
+#add_context test_run: TestRun;
+#add_context started_at: Apollo_Time;
+
+#import "Basic";
+#import "Compiler";
+#import "File";
+#import "Program_Print";

exercises/practice/isbn-verifier/solution.jai

@@ -0,0 +1,3 @@
+is_valid :: (isbn: string) -> bool {
+    // TODO: implement this procedure
+}