trackler 2.0.8.19 → 2.0.8.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a18e7d1d01de5dac14394d4c662332c16d96702
-  data.tar.gz: ea97a61252024003df91aed43f471bed17ebd3eb
+  metadata.gz: eb72b896068a0db09871303423eb36d77ae12e79
+  data.tar.gz: b4f173c7a80ecc1a8dad8b60f163a92085a97a82
 SHA512:
-  metadata.gz: fd8893f9ee7a77e3cd946e475be1dd3d598a3749fd167037ac5279ccdeb01e88d3caf2bdedcee4cbceb161be47705ac79d4443be9238e2faf5e39599a16213d8
-  data.tar.gz: 13dd5a5e0552cb679fce68a2adbccb3fb588aa31ab627420cc81d4855f82fe56ed13138caa90c8965a08e6cca4f62577390117ed40cc58ca69024c0e0d063dda
+  metadata.gz: 36f010e19529f3ff4f39e0a8b3aa16ecbba03834b7fbc36a644e1abef9dc9e1d05e3bb17a81c3ffdecc2daeb9ed0d3c08d68387b1559cd8b3154bad7cf52a2bf
+  data.tar.gz: 9ebce40e4a533258b9920f11ae1354e29aeb926704bf074eb05733d13364335be3e93a993e6f8b3fd7422c131286c3a4d9d38c244ebbe5e0b4b8e8198d0838dc

data/common/exercises/phone-number/canonical-data.json

@@ -1,6 +1,6 @@
 {
   "exercise": "phone-number",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "cases": [
     {
       "description": "Cleanup user-entered phone numbers",
@@ -35,7 +35,7 @@
           "expected": null
         },
         {
-          "description": "invalid when 11 digits",
+          "description": "invalid when 11 digits does not start with a 1",
           "property": "clean",
           "phrase": "21234567890",
           "expected": null

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.19"
+  VERSION = "2.0.8.20"
 end

data/tracks/c/config.json

@@ -238,6 +238,13 @@
      "topics": [
         "Functions"
      ]
+  }, {
+     "difficulty": 10,
+     "slug": "react",
+     "topics": [
+        "memory management",
+        "Functions"
+     ]
   }],
   "deprecated": [
 

data/tracks/c/exercises/react/makefile

@@ -0,0 +1,16 @@
+CFLAGS  = -std=c99
+CFLAGS += -Wall
+CFLAGS += -Wextra
+CFLAGS += -pedantic
+CFLAGS += -Werror
+
+
+test: tests.out
+	@./tests.out
+
+clean:
+	rm -f *.o *.out
+
+tests.out: test/test_react.c src/react.c src/react.h
+	@echo Compiling $@
+	@cc $(CFLAGS) src/react.c test/vendor/unity.c test/test_react.c -o tests.out

data/tracks/c/exercises/react/src/example.c

@@ -0,0 +1,185 @@
+#include <stdlib.h>
+#include "react.h"
+
+enum cell_kind {
+   kind_input,
+   kind_compute1,
+   kind_compute2,
+};
+
+struct child {
+   struct cell *cell;
+   struct child *next;
+};
+
+struct cb {
+   callback_id id;
+   callback f;
+   void *obj;
+   struct cb *next;
+};
+
+struct reactor {
+   struct child *first;
+   struct child *last;
+};
+
+struct cell {
+   struct reactor *reactor;
+   int value;
+   enum cell_kind kind;
+   struct cell *input1;
+   struct cell *input2;
+   compute1 compute1;
+   compute2 compute2;
+   struct cb *cb;
+   int callbacks_issued;
+};
+
+struct reactor *create_reactor()
+{
+   return calloc(1, sizeof(struct reactor));
+}
+
+void destroy_reactor(struct reactor *r)
+{
+   struct child *child = r->first;
+   while (child) {
+      struct cb *cb = child->cell->cb;
+      while (cb) {
+         struct cb *next_cb = cb->next;
+         free(cb);
+         cb = next_cb;
+      }
+      free(child->cell);
+
+      struct child *next = child->next;
+      free(child);
+      child = next;
+   }
+   free(r);
+}
+
+static void add_child(struct reactor *r, struct cell *cell)
+{
+   struct child *child = calloc(1, sizeof(struct child));
+   child->cell = cell;
+   if (!r->first) {
+      r->first = child;
+   } else {
+      r->last->next = child;
+   }
+   r->last = child;
+}
+
+struct cell *create_input_cell(struct reactor *r, int initial_value)
+{
+   struct cell *c = calloc(1, sizeof(struct cell));
+   add_child(r, c);
+   c->reactor = r;
+   c->kind = kind_input;
+   c->value = initial_value;
+   return c;
+}
+
+struct cell *create_compute1_cell(struct reactor *r, struct cell *input,
+                                  compute1 compute)
+{
+   struct cell *c = calloc(1, sizeof(struct cell));
+   add_child(r, c);
+   c->reactor = r;
+   c->kind = kind_compute1;
+   c->input1 = input;
+   c->compute1 = compute;
+   c->value = compute(get_cell_value(input));
+   return c;
+}
+
+struct cell *create_compute2_cell(struct reactor *r, struct cell *input1,
+                                  struct cell *input2, compute2 compute)
+{
+   struct cell *c = calloc(1, sizeof(struct cell));
+   add_child(r, c);
+   c->reactor = r;
+   c->kind = kind_compute2;
+   c->input1 = input1;
+   c->input2 = input2;
+   c->compute2 = compute;
+   c->value = compute(get_cell_value(input1), get_cell_value(input2));
+   return c;
+}
+
+int get_cell_value(struct cell *c)
+{
+   return c->value;
+}
+
+static void propagate(struct cell *c)
+{
+   int new_value;
+   switch (c->kind) {
+   case kind_compute1:
+      new_value = c->compute1(get_cell_value(c->input1));
+      break;
+   case kind_compute2:
+      new_value =
+          c->compute2(get_cell_value(c->input1), get_cell_value(c->input2));
+      break;
+   default:
+      return;
+   }
+
+   if (new_value != c->value) {
+      c->value = new_value;
+      for (struct cb * cb = c->cb; cb; cb = cb->next) {
+         cb->f(cb->obj, new_value);
+      }
+   }
+
+}
+
+void set_cell_value(struct cell *c, int new_value)
+{
+   c->value = new_value;
+   struct reactor *r = c->reactor;
+
+   // We take the very naive route of updating all cells.
+   // Traversing the tree and only updating the cells dependent on the just-changed cell is possible,
+   // but requires much more memory management to make each cell aware of its dependents.
+   for (struct child * child = r->first; child; child = child->next) {
+      propagate(child->cell);
+   }
+}
+
+callback_id add_callback(struct cell *c, void *obj, callback f)
+{
+   struct cb *cb = calloc(1, sizeof(struct cb));
+   cb->id = c->callbacks_issued++;
+   cb->next = c->cb;
+   cb->obj = obj;
+   cb->f = f;
+   c->cb = cb;
+   return cb->id;
+}
+
+void remove_callback(struct cell *c, callback_id to_remove)
+{
+   if (!c->cb) {
+      return;
+   }
+   // this dummy starting node reduces code duplication,
+   // in case the ID to remove is at the head of the list.
+   struct cb dummy;
+   dummy.next = c->cb;
+   for (struct cb * prev = &dummy, *cb = c->cb; cb;
+        prev = prev->next, cb = cb->next) {
+      if (cb->id == to_remove) {
+         if (cb == c->cb) {
+            c->cb = cb->next;
+         }
+         prev->next = cb->next;
+         free(cb);
+         return;
+      }
+   }
+}

data/tracks/c/exercises/react/src/react.h

@@ -0,0 +1,29 @@
+#ifndef REACT_H
+#define REACT_H
+
+struct reactor;
+struct cell;
+
+typedef int (*compute1) (int);
+typedef int (*compute2) (int, int);
+
+struct reactor *create_reactor();
+// destroy_reactor should free all cells created under that reactor.
+void destroy_reactor(struct reactor *);
+
+struct cell *create_input_cell(struct reactor *, int initial_value);
+struct cell *create_compute1_cell(struct reactor *, struct cell *, compute1);
+struct cell *create_compute2_cell(struct reactor *, struct cell *,
+                                  struct cell *, compute2);
+
+int get_cell_value(struct cell *);
+void set_cell_value(struct cell *, int new_value);
+
+typedef void (*callback) (void *, int);
+typedef int callback_id;
+
+// The callback should be called with the same void * given in add_callback.
+callback_id add_callback(struct cell *, void *, callback);
+void remove_callback(struct cell *, callback_id);
+
+#endif

data/tracks/c/exercises/react/test/test_react.c

@@ -0,0 +1,324 @@
+#include <stddef.h>
+#include <stdio.h>
+#include "vendor/unity.h"
+#include "../src/react.h"
+
+void test_input_cells_have_value(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 2);
+
+   TEST_ASSERT_EQUAL_INT(2, get_cell_value(input));
+
+   destroy_reactor(r);
+}
+
+void test_input_cells_value_can_be_set(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 4);
+
+   set_cell_value(input, 20);
+   TEST_ASSERT_EQUAL_INT(20, get_cell_value(input));
+
+   destroy_reactor(r);
+}
+
+static int plus1(int x)
+{
+   return x + 1;
+}
+
+void test_compute_cells_calculate_initial_value(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 1);
+   struct cell *output = create_compute1_cell(r, input, plus1);
+
+   TEST_ASSERT_EQUAL_INT(2, get_cell_value(output));
+
+   destroy_reactor(r);
+}
+
+static int concat_digits(int a, int b)
+{
+   return b * 10 + a;
+}
+
+void test_compute_cells_take_inputs_in_the_right_order(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *one = create_input_cell(r, 1);
+   struct cell *two = create_input_cell(r, 2);
+   struct cell *output = create_compute2_cell(r, one, two, concat_digits);
+
+   TEST_ASSERT_EQUAL_INT(21, get_cell_value(output));
+
+   destroy_reactor(r);
+}
+
+void test_compute_cells_update_value_when_dependencies_are_changed(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 1);
+   struct cell *output = create_compute1_cell(r, input, plus1);
+
+   set_cell_value(input, 3);
+   TEST_ASSERT_EQUAL_INT(4, get_cell_value(output));
+
+   destroy_reactor(r);
+}
+
+static int times2(int x)
+{
+   return x * 2;
+}
+
+static int times30(int x)
+{
+   return x * 30;
+}
+
+static int plus(int x, int y)
+{
+   return x + y;
+}
+
+void test_compute_cells_can_depend_on_other_compute_cells(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 1);
+   struct cell *times_two = create_compute1_cell(r, input, times2);
+   struct cell *times_thirty = create_compute1_cell(r, input, times30);
+   struct cell *output = create_compute2_cell(r, times_two, times_thirty, plus);
+
+   TEST_ASSERT_EQUAL_INT(32, get_cell_value(output));
+   set_cell_value(input, 3);
+   TEST_ASSERT_EQUAL_INT(96, get_cell_value(output));
+
+   destroy_reactor(r);
+}
+
+struct cbinfo {
+   int last_value;
+   int times_called;
+};
+
+static void cb_spy(void *obj, int v)
+{
+   struct cbinfo *cbinfo = (struct cbinfo *)obj;
+   cbinfo->last_value = v;
+   ++cbinfo->times_called;
+}
+
+void test_compute_cells_fire_callbacks(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 1);
+   struct cell *output = create_compute1_cell(r, input, plus1);
+
+   struct cbinfo cbinfo = { -1, 0 };
+   add_callback(output, &cbinfo, cb_spy);
+
+   set_cell_value(input, 3);
+   TEST_ASSERT_EQUAL_INT(1, cbinfo.times_called);
+   TEST_ASSERT_EQUAL_INT(4, cbinfo.last_value);
+
+   destroy_reactor(r);
+}
+
+static void cb_noop(void *obj, int v)
+{
+   (void)obj;
+   (void)v;
+}
+
+void test_compute_cells_dont_access_callback_obj(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 1);
+   struct cell *output = create_compute1_cell(r, input, plus1);
+
+   add_callback(output, NULL, cb_noop);
+
+   set_cell_value(input, 3);
+
+   destroy_reactor(r);
+}
+
+static int big_if_three(int x)
+{
+   return x < 3 ? 111 : 222;
+}
+
+void test_callbacks_only_fire_on_change(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 1);
+   struct cell *output = create_compute1_cell(r, input, big_if_three);
+
+   struct cbinfo cbinfo = { -1, 0 };
+   add_callback(output, &cbinfo, cb_spy);
+
+   set_cell_value(input, 2);
+   TEST_ASSERT_EQUAL_INT(0, cbinfo.times_called);
+
+   set_cell_value(input, 4);
+   TEST_ASSERT_EQUAL_INT(1, cbinfo.times_called);
+   TEST_ASSERT_EQUAL_INT(222, cbinfo.last_value);
+
+   destroy_reactor(r);
+}
+
+void test_callbacks_can_be_added_and_removed(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 11);
+   struct cell *output = create_compute1_cell(r, input, plus1);
+
+   struct cbinfo cbinfo1 = { -1, 0 };
+   callback_id cb1 = add_callback(output, &cbinfo1, cb_spy);
+   struct cbinfo cbinfo2 = { -1, 0 };
+   add_callback(output, &cbinfo2, cb_spy);
+
+   set_cell_value(input, 31);
+
+   remove_callback(output, cb1);
+   struct cbinfo cbinfo3 = { -1, 0 };
+   add_callback(output, &cbinfo3, cb_spy);
+
+   set_cell_value(input, 41);
+
+   TEST_ASSERT_EQUAL_INT(1, cbinfo1.times_called);
+   TEST_ASSERT_EQUAL_INT(32, cbinfo1.last_value);
+   TEST_ASSERT_EQUAL_INT(2, cbinfo2.times_called);
+   TEST_ASSERT_EQUAL_INT(42, cbinfo2.last_value);
+   TEST_ASSERT_EQUAL_INT(1, cbinfo3.times_called);
+   TEST_ASSERT_EQUAL_INT(42, cbinfo3.last_value);
+
+   destroy_reactor(r);
+}
+
+void test_removing_most_recent_callback(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 11);
+   struct cell *output = create_compute1_cell(r, input, plus1);
+
+   struct cbinfo cbinfo1 = { -1, 0 };
+   add_callback(output, &cbinfo1, cb_spy);
+   struct cbinfo cbinfo2 = { -1, 0 };
+   callback_id cb2 = add_callback(output, &cbinfo2, cb_spy);
+   remove_callback(output, cb2);
+
+   set_cell_value(input, 31);
+
+   TEST_ASSERT_EQUAL_INT(1, cbinfo1.times_called);
+   TEST_ASSERT_EQUAL_INT(32, cbinfo1.last_value);
+   TEST_ASSERT_EQUAL_INT(0, cbinfo2.times_called);
+
+   destroy_reactor(r);
+}
+
+void test_removing_a_callback_multiple_times(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 11);
+   struct cell *output = create_compute1_cell(r, input, plus1);
+
+   struct cbinfo cbinfo1 = { -1, 0 };
+   callback_id cb1 = add_callback(output, &cbinfo1, cb_spy);
+   struct cbinfo cbinfo2 = { -1, 0 };
+   add_callback(output, &cbinfo2, cb_spy);
+   for (int i = 0; i < 10; ++i) {
+      remove_callback(output, cb1);
+   }
+
+   set_cell_value(input, 2);
+
+   TEST_ASSERT_EQUAL_INT(0, cbinfo1.times_called);
+   TEST_ASSERT_EQUAL_INT(1, cbinfo2.times_called);
+   TEST_ASSERT_EQUAL_INT(3, cbinfo2.last_value);
+
+   destroy_reactor(r);
+}
+
+static int minus1(int x)
+{
+   return x - 1;
+}
+
+static int times(int x, int y)
+{
+   return x * y;
+}
+
+void test_callbacks_only_called_once_even_if_multiple_inputs_change(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 1);
+   struct cell *plus_one = create_compute1_cell(r, input, plus1);
+   struct cell *minus_one1 = create_compute1_cell(r, input, minus1);
+   struct cell *minus_one2 = create_compute1_cell(r, minus_one1, minus1);
+   struct cell *output = create_compute2_cell(r, plus_one, minus_one2, times);
+
+   struct cbinfo cbinfo = { -1, 0 };
+   add_callback(output, &cbinfo, cb_spy);
+
+   set_cell_value(input, 4);
+
+   TEST_ASSERT_EQUAL_INT(1, cbinfo.times_called);
+   TEST_ASSERT_EQUAL_INT(10, cbinfo.last_value);
+
+   destroy_reactor(r);
+}
+
+static int minus(int x, int y)
+{
+   return x - y;
+}
+
+void test_callbacks_not_called_if_inputs_change_but_output_doesnt(void)
+{
+   struct reactor *r = create_reactor();
+   struct cell *input = create_input_cell(r, 1);
+   struct cell *plus_one = create_compute1_cell(r, input, plus1);
+   struct cell *minus_one = create_compute1_cell(r, input, minus1);
+   struct cell *always_two =
+       create_compute2_cell(r, plus_one, minus_one, minus);
+
+   struct cbinfo cbinfo = { -1, 0 };
+   add_callback(always_two, &cbinfo, cb_spy);
+
+   for (int i = 0; i < 10; ++i) {
+      set_cell_value(input, i);
+   }
+
+   TEST_ASSERT_EQUAL_INT(0, cbinfo.times_called);
+
+   destroy_reactor(r);
+}
+
+int main(void)
+{
+   UnityBegin("test/test_react.c");
+
+   RUN_TEST(test_input_cells_have_value);
+   RUN_TEST(test_input_cells_value_can_be_set);
+   RUN_TEST(test_compute_cells_calculate_initial_value);
+   RUN_TEST(test_compute_cells_take_inputs_in_the_right_order);
+   RUN_TEST(test_compute_cells_update_value_when_dependencies_are_changed);
+   RUN_TEST(test_compute_cells_can_depend_on_other_compute_cells);
+   RUN_TEST(test_compute_cells_fire_callbacks);
+   RUN_TEST(test_compute_cells_dont_access_callback_obj);
+   RUN_TEST(test_callbacks_only_fire_on_change);
+   RUN_TEST(test_callbacks_can_be_added_and_removed);
+   RUN_TEST(test_removing_most_recent_callback);
+   RUN_TEST(test_removing_a_callback_multiple_times);
+   RUN_TEST(test_callbacks_only_called_once_even_if_multiple_inputs_change);
+   RUN_TEST(test_callbacks_not_called_if_inputs_change_but_output_doesnt);
+
+   UnityEnd();
+
+   return 0;
+}