trackler 2.2.1.53 → 2.2.1.54

data/tracks/cfml/tasks/GenerateReadme.cfc

@@ -15,7 +15,7 @@ component  {
 		/* Init global variables */
 		repoRootPath = expandPath( getDirectoryFromPath( getCurrentTemplatePath() ) & '../' );
 		problemSpecsPath = expandPath( getDirectoryFromPath( getCurrentTemplatePath() ) & '../../problem-specifications' );
-		trackReadmeInsert= fileRead( repoRootPath & "docs/EXERCISE_README_INSERT.md" );
+		trackReadmeInsert= fileRead( repoRootPath & "docs/EXERCISE_README_INSERT.md", "utf-8" );
 		overwriteExistingFiles = arguments.force;	
 
 		if( !directoryExists( problemSpecsPath ) ){
@@ -65,7 +65,7 @@ component  {
 			readmeContent = readmeContent & "#### Submitting Incomplete Solutions#chr( 10 )#It's possible to submit an incomplete solution so you can see how others have completed the exercise.#chr( 10 )#";
 
 			/* Write the file */
-			fileWrite( readMeFile , readmeContent );
+			fileWrite( readMeFile , readmeContent, "utf-8" );
 
 			print.greenLine( 'Readme generated!' )
 				.indentedYellowLine( readMeFile )
@@ -87,7 +87,7 @@ component  {
 	private function getHints( required string slug ) {
 
 		var hintsFilePath = repoRootPath & "/exercises/" & arguments.slug & "/.meta/hints.md";
-		var hints = fileExists( hintsFilePath ) ? fileRead( hintsFilePath ) : "";
+		var hints = fileExists( hintsFilePath ) ? fileRead( hintsFilePath, "utf-8" ) : "";
 
 		return hints;
 	}
@@ -119,7 +119,7 @@ component  {
 
 		var descriptionFilePath = problemSpecsPath & "/exercises/" & arguments.slug & "/description.md";
 		 
-		return fileExists( descriptionFilePath ) ? trim( fileRead( descriptionFilePath ) ) : "";
+		return fileExists( descriptionFilePath ) ? trim( fileRead( descriptionFilePath, "utf-8" ) ) : "";
 	}
 
 	/**
@@ -163,7 +163,7 @@ component  {
 	private struct function getExerciseMetadata( required string slug ) {
 
 		var metadataFilePath = problemSpecsPath & "/exercises/" & arguments.slug & "/metadata.yml";
-		var content = fileRead(metadataFilePath);
+		var content = fileRead( metadataFilePath , "utf-8");
 		var metadata = {};
 
 		/* Get the title if provided in metadata.yml */

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

@@ -10,26 +10,103 @@
 %%====================================================================
 
 %% escript Entry point
-main([]) ->
-    io:format("Searching for git basedir~n"),
-    {ok, PWD} = file:get_cwd(),
-    case tg_git_tools:find_git(PWD) of
-        {ok, GitDir} -> main([GitDir]);
-        error -> io:format("No git basedir found, please specifiy manually~n")
-    end;
-main([GitPath]) ->
-    io:format("Using ~s as basepath~n", [GitPath]),
-    SpecFiles0 = filelib:wildcard("canonical_data/exercises/*/canonical-data.json", GitPath),
-    SpecFiles1 = lists:filtermap(fun filter_by_generator_and_create_record/1, SpecFiles0),
-    SpecFiles2 = lists:map(fun(TGen) -> TGen#tgen{path = GitPath ++ "/" ++ TGen#tgen.path, dest = GitPath ++ "/exercises/" ++ TGen#tgen.name} end, SpecFiles1),
-    lists:map(fun tgen:generate/1, SpecFiles2).
+main(Args) ->
+    Config = process_args(Args, #{}),
+    execute(Config).
 
 %%====================================================================
 %% Internal functions
 %%====================================================================
 
-filter_by_generator_and_create_record(Path) ->
-    Name = tg_file_tools:extract_name(Path),
+process_args([], Config = #{path := _, spec_path := _, out_path := _}) ->
+    case maps:is_key(exercises, Config) of
+        false -> maps:put(exercises, all, Config);
+        true -> Config
+    end;
+process_args([], Config = #{path := Path}) ->
+    Config1 = case maps:is_key(spec_path, Config) of
+        false -> maps:put(spec_path, iolist_to_binary([Path, "/canonical_data/exercises"]), Config);
+        true -> Config
+    end,
+
+    Config2 = case maps:is_key(out_path, Config1) of
+        false -> maps:put(out_path, iolist_to_binary([Path, "/exercises"]), Config1);
+        true -> Config1
+    end,
+
+    process_args([], Config2);
+process_args([], Config) ->
+    Config1 = case maps:is_key(path, Config) and not (maps:is_key(out_path, Config) or maps:is_key(spec_path, Config)) of
+        false -> maps:put(path, search_git_upwards(), Config);
+        true -> Config
+    end,
+
+    Config2 = case maps:is_key(command, Config1) of
+        false -> maps:put(command, "generate", Config1);
+        true -> Config1
+    end,
+
+    process_args([], Config2);
+process_args(["--path", Path|Args], Config) ->
+    process_args(Args, maps:put(path, Path, Config));
+process_args(["--spec-path", SpecPath|Args], Config) ->
+    process_args(Args, maps:put(spec_path, SpecPath, Config));
+process_args(["--out-path", OutPath|Args], Config) ->
+    process_args(Args, maps:put(out_path, OutPath, Config));
+process_args([Arg|Args], Config) ->
+    Config1 = case maps:is_key(command, Config) of
+        false ->
+            maps:put(command, Arg, Config);
+        true ->
+            maps:update_with(exercises, fun(Tail) -> [Arg|Tail] end, [Arg], Config)
+    end,
+    process_args(Args, Config1).
+
+search_git_upwards() ->
+    {ok, PWD} = file:get_cwd(),
+    case tg_git_tools:find_git(PWD) of
+        {ok, GitDir} -> GitDir;
+        error -> error
+    end.
+
+execute(Config = #{command := "generate", spec_path := SpecPath, exercises := all}) ->
+    SpecFiles = filelib:wildcard("*/canonical-data.json", binary_to_list(SpecPath)),
+    Exercises = lists:map(fun tg_file_tools:extract_name/1, SpecFiles),
+    put(log_unavailable, false), % TODO: Get rid of the use of the process dictionary!
+    execute(maps:put(exercises, Exercises, Config));
+execute(#{command := "generate", spec_path := SpecPath, out_path := OutPath, exercises := [_|_] = Exercises}) ->
+    case get(log_unavailable) of % TODO: Get rid of the use of the process dictionary!
+        undefined -> put(log_unavailable, true);
+        _ -> ok
+    end,
+    SpecFiles = lists:map(fun (Exercise) -> {Exercise, iolist_to_binary([SpecPath, $/, Exercise, "/canonical-data.json"])} end, Exercises),
+    Generators0 = lists:filtermap(fun filter_by_generator_and_create_record/1, SpecFiles),
+    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])
+        end, Contents);
+execute(#{command := "check"}) ->
+    io:format("This command has not been implemented yet");
+execute(#{command := "help"}) ->
+    io:format("This command has not been implemented yet");
+execute(_) ->
+    io:format("Unknown command. Only generate is available right now.").
+
+
+filter_by_generator_and_create_record({Name, Path}) ->
     case tgen:check(Name) of
         {true, Module} ->
             {true, #tgen{
@@ -37,5 +114,10 @@ filter_by_generator_and_create_record(Path) ->
                 name   = Name,
                 path   = Path
             }};
-        _ -> false
-    end.
+        _ ->
+            case get(log_unavailable) of
+                true -> io:format("No generator for '~s' available~n", [Name]);
+                _ -> ok
+            end,
+            false
+    end.

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

@@ -5,10 +5,10 @@
     parent_dir/1
 ]).
 
-extract_name("canonical_data/exercises/" ++ Rest) ->
-    lists:takewhile(fun(C) -> not lists:member(C, [$/, $\\]) end, Rest).
+extract_name(Name) ->
+    lists:takewhile(fun(C) -> not lists:member(C, [$/, $\\]) end, Name).
 
 parent_dir(Dir) ->
     DirRev0 = lists:reverse(Dir),
     DirRev1 = lists:dropwhile(fun(C) -> not lists:member(C, [$/, $\\]) end, DirRev0),
-    lists:reverse(tl(DirRev1)).
+    lists:reverse(tl(DirRev1)).

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

@@ -44,15 +44,23 @@ check(Name) ->
         _:_ -> false
     end.
 
--spec generate(tgen()) -> ok. 
+-spec generate(tgen()) -> ok.
 generate(Generator = #tgen{}) ->
-    io:format("Generating ~s~n", [Generator#tgen.name]),
+    io:format("Generating ~s", [Generator#tgen.name]),
     case file:read_file(Generator#tgen.path) of
         {ok, Content} ->
             {ModName, TestModule} = process_json(Generator, Content),
-            {ok, IODevice} = file:open([Generator#tgen.dest, "/test/", ModName, ".erl"], [write]),
-            io:format(IODevice, "~s", [TestModule]),
-            file:close(IODevice)
+            TestfilePath = iolist_to_binary([Generator#tgen.dest, "/test/", ModName, ".erl"]),
+            io:format(", finished~n"),
+            #{
+                name   => Generator#tgen.name,
+                module => ModName,
+                impl   => TestModule,
+                path   => TestfilePath
+            };
+        {error, Reason} ->
+            io:format(", failed (~p)~n", [Reason]),
+            {error, Reason, Generator#tgen.path}
     end.
 
 process_json(G = #tgen{name = GName}, Content) when is_list(GName) ->
@@ -66,7 +74,7 @@ process_json(#tgen{name = GName, module = Module}, Content) ->
                 {[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])};
         #{exercise := Name} ->
             io:format("Name in JSON (~p) and name for generator (~p) do not line up", [Name, GName])
@@ -123,4 +131,4 @@ generate_module(ModuleName, Tests, Version) ->
 
 inter(_, []) -> [];
 inter(_, [X]) -> [X];
-inter(Delim, [X|Xs]) -> [X, Delim|Xs].
+inter(Delim, [X|Xs]) -> [X, Delim|Xs].

data/tracks/haskell/config.json

@@ -65,7 +65,8 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
-        "Maybe"
+        "Maybe",
+        "Number Theory"
       ]
     },
     {
@@ -103,6 +104,7 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
+        "Number Theory"
       ]
     },
     {
@@ -112,6 +114,7 @@
       "unlocked_by": null,
       "difficulty": 1,
       "topics": [
+        "Number Theory"
       ]
     },
     {
@@ -130,6 +133,8 @@
       "unlocked_by": null,
       "difficulty": 2,
       "topics": [
+        "Define type",
+        "Number Theory"
       ]
     },
     {
@@ -139,7 +144,8 @@
       "unlocked_by": null,
       "difficulty": 2,
       "topics": [
-        "Maybe"
+        "Maybe",
+        "Number Theory"
       ]
     },
     {
@@ -248,6 +254,7 @@
       "unlocked_by": null,
       "difficulty": 3,
       "topics": [
+        "Number Theory"
       ]
     },
     {
@@ -344,6 +351,7 @@
       "unlocked_by": null,
       "difficulty": 4,
       "topics": [
+        "Number Theory"
       ]
     },
     {
@@ -413,6 +421,7 @@
       "unlocked_by": null,
       "difficulty": 4,
       "topics": [
+        "Number Theory"
       ]
     },
     {
@@ -422,6 +431,7 @@
       "unlocked_by": null,
       "difficulty": 4,
       "topics": [
+        "Number Theory"
       ]
     },
     {
@@ -449,6 +459,7 @@
       "unlocked_by": null,
       "difficulty": 4,
       "topics": [
+        "Number Theory"
       ]
     },
     {
@@ -486,7 +497,8 @@
       "unlocked_by": null,
       "difficulty": 5,
       "topics": [
-        "Maybe"
+        "Maybe",
+        "Number Theory"
       ]
     },
     {

data/tracks/java/scripts/canonical_data_check.sh

@@ -106,7 +106,7 @@ do
 
 done
 
-if [ $update_needed_count -eq 1 ]
+if [ $update_needed_count -eq 0 ]
 then
     echo "All exercises are up to date!"
 fi

data/tracks/javascript/config.json

@@ -1123,6 +1123,18 @@
         "strings",
         "algorithms"
       ]
+    },
+    {
+      "uuid": "f4a3d66a-04a8-3e80-6c9a-8a573ccb26fd9ed1d5c",
+      "slug": "zipper",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 8,
+      "topics": [
+        "recursion",
+        "searching",
+        "trees"
+      ]
     }
   ],
   "foregone": [],

data/tracks/javascript/exercises/difference-of-squares/README.md

@@ -1,4 +1,4 @@
-# Difference Of Squares
+# Difference of Squares
 
 Find the difference between the square of the sum and the sum of the squares of the first N natural numbers.
 

data/tracks/javascript/exercises/sum-of-multiples/README.md

@@ -1,4 +1,4 @@
-# Sum Of Multiples
+# Sum of Multiples
 
 Given a number, find the sum of all the multiples of particular numbers up to
 but not including that number.

data/tracks/javascript/exercises/zipper/README.md

@@ -0,0 +1,55 @@
+# Zipper
+
+Creating a zipper for a binary tree.
+
+[Zippers](https://en.wikipedia.org/wiki/Zipper_%28data_structure%29) are
+a way purely functional of navigating within a data structure and
+manipulating it.  They essentially contain a data structure and a
+pointer into that data structure (called the focus).
+
+For example given a rose tree (where each node contains a value and a
+list of child nodes) a zipper might support these operations:
+
+- `from_tree` (get a zipper out of a rose tree, the focus is on the root node)
+- `to_tree` (get the rose tree out of the zipper)
+- `value` (get the value of the focus node)
+- `prev` (move the focus to the previous child of the same parent,
+  returns a new zipper)
+- `next` (move the focus to the next child of the same parent, returns a
+  new zipper)
+- `up` (move the focus to the parent, returns a new zipper)
+- `set_value` (set the value of the focus node, returns a new zipper)
+- `insert_before` (insert a new subtree before the focus node, it
+  becomes the `prev` of the focus node, returns a new zipper)
+- `insert_after` (insert a new subtree after the focus node, it becomes
+  the `next` of the focus node, returns a new zipper)
+- `delete` (removes the focus node and all subtrees, focus moves to the
+  `next` node if possible otherwise to the `prev` node if possible,
+  otherwise to the parent node, returns a new zipper)
+
+  ## Setup
+
+  Go through the setup instructions for JavaScript to
+  install the necessary dependencies:
+
+  http://exercism.io/languages/javascript
+
+  ## Making the Test Suite Pass
+
+  Execute the tests with:
+
+      jasmine <exercise-name>.spec.js
+
+  Replace `<exercise-name>` with the name of the current exercise. E.g., to
+  test the Hello World exercise:
+
+      jasmine hello-world.spec.js
+
+  All but the first test have been skipped.
+
+  Once you get a test passing, you can unskip the next one by
+  changing `xit` to `it`.
+
+
+  ## Submitting Incomplete Solutions
+  It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/javascript/exercises/zipper/example.js

@@ -0,0 +1,100 @@
+'use strict';
+
+function fromTrail(tree, last) {
+  if (last[0] === 'left') {
+    return {
+      value: last[1],
+      left: tree,
+      right: last[2]
+    };
+  }
+  return {
+    value: last[1],
+    left: last[2],
+    right: tree
+  };
+}
+
+function rebuildTree(tree, trail) {
+  if (trail.length === 0) return tree;
+
+  var last = trail[0];
+  return rebuildTree(fromTrail(tree, last), trail.slice(1));
+}
+
+var Zipper = function (tree, trail) {
+  this.tree = tree;
+  this.trail = trail;
+};
+
+Zipper.fromTree = function (tree) {
+  return new Zipper(tree, []);
+};
+
+Zipper.prototype.toTree = function () {
+  return rebuildTree(this.tree, this.trail);
+};
+
+Zipper.prototype.value = function () {
+  return this.tree.value;
+};
+
+Zipper.prototype.left = function () {
+  if (!this.tree.left) return null;
+
+  return new Zipper(
+    this.tree.left,
+    [['left', this.tree.value, this.tree.right]].concat(this.trail)
+  );
+};
+
+Zipper.prototype.right = function () {
+  if (!this.tree.right) return null;
+
+  return new Zipper(
+    this.tree.right,
+    [['right', this.tree.value, this.tree.left]].concat(this.trail)
+  );
+};
+
+Zipper.prototype.up = function () {
+  if (this.trail.length === 0) return null;
+
+  var last = this.trail[0];
+  return new Zipper(fromTrail(this.tree, last), this.trail.slice(1));
+};
+
+Zipper.prototype.setValue = function (value) {
+  return new Zipper(
+    {
+      value: value,
+      left: this.tree.left,
+      right: this.tree.right
+    },
+    this.trail
+  );
+};
+
+Zipper.prototype.setLeft = function (left) {
+  return new Zipper(
+    {
+      value: this.tree.value,
+      left: left,
+      right: this.tree.right
+    },
+    this.trail
+  );
+};
+
+Zipper.prototype.setRight = function (right) {
+  return new Zipper(
+    {
+      value: this.tree.value,
+      left: this.tree.left,
+      right: right
+    },
+    this.trail
+  );
+};
+
+module.exports = Zipper;