trackler 2.2.1.54 → 2.2.1.55

data/tracks/ecmascript/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/erlang/exercises/collatz-conjecture/src/collatz_conjecture.erl

@@ -2,8 +2,7 @@
 
 -export([steps/1, test_version/0]).
 
-steps(N) ->
-  undefined.
 
-test_version() ->
-  1.
+steps(N) -> undefined.
+
+test_version() -> 2.

data/tracks/erlang/exercises/collatz-conjecture/src/example.erl

@@ -3,15 +3,15 @@
 -export([steps/1,
          test_version/0]).
 
-steps(N) when N =< 0 -> {error, "Only strictly positive numbers are allowed"};
+steps(N) when N =< 0 -> {error, "Only positive numbers are allowed"};
 steps(N) ->
   steps(N, 0).
 
 test_version() ->
-  1.
+  2.
 
 
 
 steps(1, Acc) -> Acc;
 steps(N, Acc) when N rem 2 =:= 0 -> steps(N div 2, Acc + 1);
-steps(N, Acc) -> steps(3 * N + 1, Acc + 1).
+steps(N, Acc) -> steps(3 * N + 1, Acc + 1).

data/tracks/erlang/exercises/collatz-conjecture/test/collatz_conjecture_tests.erl

@@ -1,24 +1,28 @@
--module('collatz_conjecture_tests').
+-module(collatz_conjecture_tests).
 
 -define(TESTED_MODULE, (sut(collatz_conjecture))).
--define(TEST_VERSION, 1).
+-define(TEST_VERSION, 2).
 -include("exercism.hrl").
 
 
 zero_steps_for_one_test() ->
-  ?assertEqual(0, ?TESTED_MODULE:steps(1)).
+    ?assertMatch(0, ?TESTED_MODULE:steps(1)).
 
 divide_if_even_test() ->
-  ?assertEqual(4, ?TESTED_MODULE:steps(16)).
+    ?assertMatch(4, ?TESTED_MODULE:steps(16)).
 
 even_and_odd_steps_test() ->
-  ?assertEqual(9, ?TESTED_MODULE:steps(12)).
+    ?assertMatch(9, ?TESTED_MODULE:steps(12)).
 
 large_number_of_even_and_odd_steps_test() ->
-  ?assertEqual(152, ?TESTED_MODULE:steps(1000000)).
-  
+    ?assertMatch(152, ?TESTED_MODULE:steps(1000000)).
+
 zero_is_an_error_test() ->
-  ?assertEqual({error, "Only strictly positive numbers are allowed"}, ?TESTED_MODULE:steps(0)).
+    ?assertMatch({error,
+		  "Only positive numbers are allowed"},
+		 ?TESTED_MODULE:steps(0)).
 
 negative_value_is_an_error_test() ->
-  ?assertEqual({error, "Only strictly positive numbers are allowed"}, ?TESTED_MODULE:steps(-15)).
+    ?assertMatch({error,
+		  "Only positive numbers are allowed"},
+		 ?TESTED_MODULE:steps(-15)).

data/tracks/erlang/exercises/hello-world/src/hello_world.erl

@@ -2,7 +2,7 @@
 
 -export([hello/0, test_version/0]).
 
-hello() ->
-  undefined.
+
+hello() -> undefined.
 
 test_version() -> 2.

data/tracks/erlang/exercises/leap/src/example.erl

@@ -9,7 +9,7 @@ leap_year(Year) ->
           not divisible_by(Year, 100)).
 
 test_version() ->
-    1.
+    3.
 
 
 

data/tracks/erlang/exercises/leap/src/leap.erl

@@ -2,7 +2,7 @@
 
 -export([leap_year/1, test_version/0]).
 
-leap_year(Year) ->
-  undefined.
 
-test_version() -> 1.
+leap_year(Year) -> undefined.
+
+test_version() -> 3.

data/tracks/erlang/exercises/leap/test/leap_tests.erl

@@ -1,18 +1,18 @@
 -module(leap_tests).
 
 -define(TESTED_MODULE, (sut(leap))).
--define(TEST_VERSION, 1).
+-define(TEST_VERSION, 3).
 -include("exercism.hrl").
 
 
-leap_year_test() ->
-  ?assert(?TESTED_MODULE:leap_year(1996)).
+year_not_divisible_by_4_common_year_test() ->
+    ?assertNot(?TESTED_MODULE:leap_year(2015)).
 
-non_leap_year_test() ->
-  ?assertNot(?TESTED_MODULE:leap_year(1997)).
+year_divisible_by_4_not_divisible_by_100_leap_year_test() ->
+    ?assert(?TESTED_MODULE:leap_year(2020)).
 
-century_test() ->
-  ?assertNot(?TESTED_MODULE:leap_year(1900)).
+year_divisible_by_100_not_divisible_by_400_common_year_test() ->
+    ?assertNot(?TESTED_MODULE:leap_year(2100)).
 
-fourth_century_test() ->
-  ?assert(?TESTED_MODULE:leap_year(2400)).
+year_divisible_by_400_leap_year_test() ->
+    ?assert(?TESTED_MODULE:leap_year(2000)).

data/tracks/erlang/testgen/src/testgen.erl

@@ -84,19 +84,22 @@ execute(#{command := "generate", spec_path := SpecPath, out_path := OutPath, exe
     Generators1 = lists:map(fun (Generator) -> Generator#tgen{dest = iolist_to_binary([OutPath, $/, Generator#tgen.name])} end, Generators0),
     Contents = lists:map(fun tgen:generate/1, Generators1),
     lists:map(
-        fun
-            (#{name := Name, impl := Impl, path := Path}) ->
-                io:format("Writing ~s", [Name]),
-                case file:open(Path, [write]) of
-                    {ok, IODevice} ->
-                        io:format(IODevice, "~s", [Impl]),
-                        file:close(IODevice),
-                        io:format(", finished~n");
-                    {error, Reason} ->
-                        io:format("Can not open ~p for writing because of ~p.~n", [Path, Reason])
-                end;
-            ({error, Reason, Path}) ->
-                io:format("Can not open ~p for reading because of ~p.~n", [Path, Reason])
+        fun (Xs = [#{exercise := ExName}|_]) ->
+            io:format("Writing ~s", [ExName]),
+            lists:map(fun
+                (#{exercise := GName, name := Name, folder := Folder, content := Content}) ->
+                    Path = lists:flatten(io_lib:format("~s/~s/~s/~s.erl", [OutPath, GName, Folder, Name])),
+                    case file:open(Path, [write]) of
+                        {ok, IODevice} ->
+                            io:format(IODevice, "~s", [Content]),
+                            file:close(IODevice);
+                        {error, Reason} ->
+                            io:format("Can not open ~p for writing because of ~p.~n", [Path, Reason])
+                    end
+                end, Xs),
+            io:format(", finished~n");
+        ({error, Reason, Path}) ->
+            io:format("Can not open ~p for reading because of ~p.~n", [Path, Reason])
         end, Contents);
 execute(#{command := "check"}) ->
     io:format("This command has not been implemented yet");

data/tracks/erlang/testgen/src/tgen.erl

@@ -29,9 +29,11 @@
 }.
 
 -callback available() -> boolean().
--callback init(canonical_data()) -> {ok, term()}.
--callback version(term()) -> string().
--callback generate_test(exercise_json(), term()) -> {ok, erl_syntax:syntax_tree() | [erl_syntax:syntax_tree()]}.
+-callback version() -> pos_integer().
+-callback generate_test(exercise_json()) ->
+    {ok,
+        erl_syntax:syntax_tree() | [erl_syntax:syntax_tree()],
+        [{string() | binary(), non_neg_integer()}]}.
 
 
 -spec check(string()) -> {true, atom()} | false.
@@ -49,15 +51,9 @@ generate(Generator = #tgen{}) ->
     io:format("Generating ~s", [Generator#tgen.name]),
     case file:read_file(Generator#tgen.path) of
         {ok, Content} ->
-            {ModName, TestModule} = process_json(Generator, Content),
-            TestfilePath = iolist_to_binary([Generator#tgen.dest, "/test/", ModName, ".erl"]),
+            Files = process_json(Generator, Content),
             io:format(", finished~n"),
-            #{
-                name   => Generator#tgen.name,
-                module => ModName,
-                impl   => TestModule,
-                path   => TestfilePath
-            };
+            Files;
         {error, Reason} ->
             io:format(", failed (~p)~n", [Reason]),
             {error, Reason, Generator#tgen.path}
@@ -69,13 +65,16 @@ process_json(#tgen{name = GName, module = Module}, Content) ->
     case jsx:decode(Content, [return_maps, {labels, attempt_atom}]) of
         _JSON = #{exercise := GName, cases := Cases} ->
             % io:format("Parsed JSON: ~p~n", [JSON]),
-            {TestImpls, _State} = lists:foldl(fun (Spec, {Tests, State}) ->
-                {ok, Test, NewState} = Module:generate_test(Spec, State),
-                {[Test|Tests], NewState}
-            end, {[], undefined}, Cases),
-            {ModuleName, ModuleContent} = generate_module(binary_to_list(GName), TestImpls, Module:version(undefined)), % TODO: Read version dynamically and pass as Integer!
-
-            {ModuleName, io_lib:format("~s", [ModuleContent])};
+            {TestImpls0, Props} = lists:foldl(fun (Spec, {Tests, OldProperties}) ->
+                {ok, Test, Properties} = Module:generate_test(Spec),
+                {[Test|Tests], combine(OldProperties, Properties)}
+            end, {[], []}, Cases),
+            TestImpls1 = lists:reverse(TestImpls0),
+            {TestModuleName, TestModuleContent} = generate_test_module(binary_to_list(GName), TestImpls1, Module:version()),
+            {StubModuleName, StubModuleContent} = generate_stub_module(binary_to_list(GName), Props, Module:version()),
+
+            [#{exercise => GName, name => TestModuleName, folder => "test", content => io_lib:format("~s", [TestModuleContent])},
+             #{exercise => GName, name => StubModuleName, folder => "src",  content => io_lib:format("~s", [StubModuleContent])}];
         #{exercise := Name} ->
             io:format("Name in JSON (~p) and name for generator (~p) do not line up", [Name, GName])
     end.
@@ -92,34 +91,50 @@ slugify(Name) when is_binary(Name) ->
         list_to_binary(slugify(binary_to_list(Name)));
 slugify(Name) when is_list(Name) ->
     lists:filtermap(fun
-        (C) when (($a =< C) and (C =< $z)) or (C == $_) -> {true, C};
+        (C) when (($0 =< C) and (C =< $9)) or (($a =< C) and (C =< $z)) or (C == $_) -> {true, C};
         (C) when (($A =< C) and (C =< $Z)) -> {true, C - $A + $a};
         (C) when (C == $\s) or (C == $-)-> {true, $_};
         (_) -> false
     end, Name).
 
-generate_module(ModuleName, Tests, Version) ->
+generate_stub_module(ModuleName, Props, Version) ->
+    SluggedModName = slugify(ModuleName),
+    VersionName = "test_version",
+    Props1 = Props ++ [{VersionName, []}],
+
+    Funs = lists:map(fun
+            ({Name, []}) ->
+                tgs:simple_fun(Name, [tgs:atom(undefined)]);
+            ({Name, Args}) when is_list(Args) ->
+                tgs:simple_fun(Name, Args, [tgs:atom(undefined)])
+        end, Props) ++ [
+            tgs:simple_fun(VersionName, [tgs:value(Version)])],
+
+    Abstract = [
+        tgs:module(SluggedModName),
+        nl,
+        tgs:export(Props1),
+        nl,
+        nl
+    ] ++ inter(nl, Funs),
+
+    {SluggedModName, lists:flatten(
+        lists:map(
+            fun (nl) -> io_lib:format("~n", []);
+                (Tree) -> io_lib:format("~s~n", [erl_prettypr:format(Tree)])
+            end, Abstract))}.
+
+generate_test_module(ModuleName, Tests, Version) ->
     SluggedModName = slugify(ModuleName),
 
     Abstract = [
-        erl_syntax:attribute(
-            erl_syntax:text("module"),
-            [erl_syntax:atom(SluggedModName ++ "_tests")]),
+        tgs:module(SluggedModName ++ "_tests"),
         nl,
-        erl_syntax:attribute(
-            erl_syntax:text("define"), [
-                erl_syntax:text("TESTED_MODULE"),
-                erl_syntax:parentheses(
-                    erl_syntax:application(
-                        erl_syntax:text("sut"), [
-                            erl_syntax:atom(SluggedModName)]))]),
-        erl_syntax:attribute(
-            erl_syntax:text("define"), [
-                erl_syntax:text("TEST_VERSION"),
-                erl_syntax:text(Version)]),
-        erl_syntax:attribute(
-            erl_syntax:text("include"), [
-                erl_syntax:abstract("exercism.hrl")]),
+        tgs:define("TESTED_MODULE",
+            tgs:parens(
+                tgs:call_fun("sut", [tgs:atom(SluggedModName)]))),
+        tgs:define("TEST_VERSION", tgs:value(Version)),
+        tgs:include("exercism.hrl"),
         nl,
         nl] ++ inter(nl, Tests),
 
@@ -131,4 +146,16 @@ generate_module(ModuleName, Tests, Version) ->
 
 inter(_, []) -> [];
 inter(_, [X]) -> [X];
-inter(Delim, [X|Xs]) -> [X, Delim|Xs].
+inter(Delim, [X|Xs]) -> [X, Delim|inter(Delim, Xs)].
+
+combine(List, []) -> List;
+combine(List, [{Name, Arity}|Xs]) when is_list(Name) ->
+    combine(List, [{list_to_binary(Name), Arity}|Xs]);
+combine(List, [{Name, _} = X|Xs]) when is_binary(Name) ->
+    List1 = insert(List, X),
+    combine(List1, Xs).
+
+insert([], X) -> [X];
+insert([X|_] = Xs, X) -> Xs;
+insert([X|XS], Y) when X < Y -> [X|insert(XS, Y)];
+insert([X|XS], Y) when X > Y -> [Y, X|XS].

data/tracks/erlang/testgen/src/tgen_collatz-conjecture.erl

@@ -0,0 +1,38 @@
+-module('tgen_collatz-conjecture').
+
+-behaviour(tgen).
+
+-export([
+    available/0,
+    version/0,
+    generate_test/1
+]).
+
+-spec available() -> true.
+available() ->
+    true.
+
+version() -> 2.
+
+generate_test(#{description := Desc, expected := #{error := Message}, property := Prop, number := Num}) ->
+    TestName = tgen:to_test_name(Desc),
+    Property = binary_to_list(Prop),
+
+    Fn = tgs:simple_fun(TestName, [
+        tgs:call_macro("assertMatch", [
+            tgs:value({error, binary_to_list(Message)}),
+            tgs:call_macro("TESTED_MODULE:" ++ Property, [
+                tgs:value(Num)])])]),
+
+    {ok, Fn, [{Prop, ["N"]}]};
+generate_test(#{description := Desc, expected := Exp, property := Prop, number := Num}) ->
+    TestName = tgen:to_test_name(Desc),
+    Property = binary_to_list(Prop),
+
+    Fn = tgs:simple_fun(TestName, [
+        tgs:call_macro("assertMatch", [
+            tgs:value(Exp),
+            tgs:call_macro("TESTED_MODULE:" ++ Property, [
+                tgs:value(Num)])])]),
+
+    {ok, Fn, [{Prop, ["N"]}]}.

data/tracks/erlang/testgen/src/tgen_hello-world.erl

@@ -4,32 +4,24 @@
 
 -export([
     available/0,
-    init/1,
-    version/1,
-    generate_test/2
+    version/0,
+    generate_test/1
 ]).
 
 -spec available() -> true.
 available() ->
     true.
 
-init(Name) ->
-    {ok, Name}.
+version() -> 2.
 
-version(_) -> "2".
-
-generate_test(#{description := Desc, expected := Exp, property := Prop}, State) ->
+generate_test(#{description := Desc, expected := Exp, property := Prop}) ->
     TestName = tgen:to_test_name(Desc),
     Expected = binary_to_list(Exp),
     Property = binary_to_list(Prop),
-    
-    Fn = erl_syntax:function(
-        erl_syntax:text(TestName), [
-            erl_syntax:clause(none, [
-                erl_syntax:application(
-                    erl_syntax:text("?assertEqual"), [
-                        erl_syntax:abstract(Expected),
-                        erl_syntax:application(
-                            erl_syntax:text("?TESTED_MODULE:" ++ Property), [])])])]),
-    
-    {ok, Fn, State}.
+
+    Fn = tgs:simple_fun(TestName, [
+            tgs:call_macro("assertEqual", [
+                tgs:value(Expected),
+                tgs:call_macro("TESTED_MODULE:" ++ Property, [])])]),
+
+    {ok, Fn, [{Prop, []}]}.

data/tracks/erlang/testgen/src/tgen_leap.erl

@@ -0,0 +1,31 @@
+-module('tgen_leap').
+
+-behaviour(tgen).
+
+-export([
+    available/0,
+    version/0,
+    generate_test/1
+]).
+
+-spec available() -> true.
+available() ->
+    true.
+
+version() -> 3.
+
+generate_test(#{description := Desc, expected := Exp, property := <<"leapYear">>, input := In}) ->
+    TestName = tgen:to_test_name(Desc),
+    Property = "leap_year",
+
+    Assert = case Exp of
+        true -> "assert";
+        false -> "assertNot"
+    end,
+
+    Fn = tgs:simple_fun(TestName, [
+        tgs:call_macro(Assert, [
+            tgs:call_macro("TESTED_MODULE:" ++ Property, [
+                tgs:value(In)])])]),
+
+    {ok, Fn, [{Property, ["Year"]}]}.