trackler 2.2.1.135 → 2.2.1.136

data/tracks/haskell/exercises/sum-of-multiples/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: SumOfMultiples
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/haskell/exercises/transpose/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: Transpose
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/haskell/exercises/triangle/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: Triangle
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/haskell/exercises/trinary/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: Trinary
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/haskell/exercises/twelve-days/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: TwelveDays
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/haskell/exercises/word-count/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: WordCount
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/haskell/exercises/wordy/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: WordProblem
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/haskell/exercises/zebra-puzzle/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: ZebraPuzzle
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/haskell/exercises/zipper/package.yaml

@@ -7,7 +7,7 @@ dependencies:
 library:
   exposed-modules: Zipper
   source-dirs: src
-  dependencies:
+  # dependencies:
   # - foo       # List here the packages you
   # - bar       # want to use in your solution.
 

data/tracks/java/CONTRIBUTING.md

@@ -9,6 +9,8 @@
 * [Advanced: Complete Local Setup](#advanced-complete-local-setup)
   * [Tip: `gradle clean` before `exercism fetch`](#tip-gradle-clean-before-exercism-fetch)
 * [Adding a New Exercise](#adding-a-new-exercise)
+* [Updating the READMEs](#updating-the-readmes)
+* [Checking tests are up to date](#checking-tests-are-up-to-date)
 
 ## Overview
 
@@ -145,10 +147,12 @@ Any completely new exercise needs to be added and accepted there before it can b
 
 There is a [general Exercism guide for porting an exercise to a new language](https://github.com/exercism/docs/blob/master/you-can-help/implement-an-exercise-from-specification.md).
 Please review this before porting an exercise to the Java track.
- 
+
 See [here](http://exercism.io/languages/java/todo) for a list of exercises that have yet to be implemented on the Java track and can therefore be ported to this track.
 Please make sure no one else has a pull request open to implement your chosen exercise before you start.
-Also please make a [dibs pull request](https://github.com/exercism/docs/blob/master/you-can-help/implement-an-exercise-from-specification.md#avoiding-duplicate-work) to make it clear to others that you are working on this exercise.
+
+It might also be a good idea to open a WIP pull request to make it clear to others that you are working on this exercise.
+This can just be a pull request with an empty commit that states which new exercise you're working on, with WIP (work in progress) in the title so that the maintainers know that it's not ready for review yet.
 
 The Java specific details you need to know about adding an exercise are:
 
@@ -166,7 +170,7 @@ The `build.gradle` file can just be copied from any other exercise submodule.
 The `README.md` file can be generated using [configlet](https://github.com/exercism/configlet/releases).
 You can do this by:
 
-  1. Download configlet and put it somewhere in your PATH
+  1. Download configlet and put it somewhere in your [PATH](https://en.wikipedia.org/wiki/PATH_(variable))
 
   2. Clone [the problem-specifications repository](https://github.com/exercism/problem-specifications).
 
@@ -180,5 +184,37 @@ If there is canonical data available you also need to create a file at `exercise
 The canonical data version can be found at the top of the canonical data file for that exercise.
 See other exercises, e.g. [acronym](https://github.com/exercism/java/tree/master/exercises/acronym/.meta), for an example `version` file.
 
+* Make sure you've followed the [track policies](https://github.com/exercism/java/blob/master/POLICIES.md), especially the ones for exercise added/updated.
+
 Hopefully that should be enough information to help you port an exercise to the Java track.
 Feel free to open an issue or post in the [Gitter exercism/java room](https://gitter.im/exercism/java) if you have any questions and we'll try and answer as soon as we can.
+
+## Updating the READMEs
+
+The `README.md` files are generated from the exercise descriptions in [problem specifications](https://github.com/exercism/problem-specifications/tree/master/exercises).
+They need to be regenerated regularly so that any changes to the descriptions in problem specifications propagate to our READMEs.
+This can be done using [configlet](https://github.com/exercism/configlet/releases):
+
+  1. Download configlet and put it somewhere in your [PATH](https://en.wikipedia.org/wiki/PATH_(variable))
+
+  2. Clone [the problem-specifications repository](https://github.com/exercism/problem-specifications).
+
+  3. Run `configlet generate . --spec-path path_to_problem_specifications` from the root of this repository.
+
+## Checking tests are up to date
+
+The tests for each exercise should follow the canonical data in [problem specifications](https://github.com/exercism/problem-specifications/tree/master/exercises) as closely as possible.
+The canonical data can change quite regularly, in which case the [canonical data version](https://github.com/exercism/problem-specifications#test-data-versioning) for that exercise will be updated.
+
+We keep track of which version of the canonical data each exercise implements in a version file, for example: https://github.com/exercism/java/blob/master/exercises/two-fer/.meta/version.
+Not all exercises have canonical data in problem specifications.
+For those that don't we don't add a version file.
+
+We have [a script](https://github.com/exercism/java/blob/master/scripts/canonical_data_check.sh) which can check if these version are up to date with the ones in problem specification.
+This script can be used to check if any version files, tests and reference implementations need updating.
+
+To run this script:
+
+  1. Clone [the problem-specifications repository](https://github.com/exercism/problem-specifications).
+
+  2. Run `./scripts/canonical_data_check.sh -t . -s --spec-path path_to_problem_specifications` from the root of this repository.

data/tracks/java/POLICIES.md

@@ -17,7 +17,7 @@ Our policies are not set-in-stone. They represent directions chosen at a point i
 
 | Track Event | Policies to review |
 |:------------|:-----------------|
-| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test); [Add hint for the first exercises without starter implementation](#add-hint-for-the-first-exercises-without-starter-implementation)
+| Exercise added/updated | [Prefer instance methods](#prefer-instance-methods); [Avoid using final](#avoid-using-final); [Adhere to best practices](#adhere-to-best-practices); [Starter implementations](#starter-implementations); [Ignore noninitial tests](#ignore-noninitial-tests); [Multiple file submissions](#multiple-file-submissions); [Name test class after class under test](#name-test-class-after-class-under-test); [Add hint for the first exercises without starter implementation](#add-hint-for-the-first-exercises-without-starter-implementation); [Reference tutorial in the first exercises](#reference-tutorial-in-the-first-exercises); [Avoid returning null](#avoid-returning-null); [Use ExpectedException](#use-expectedexception)
 | Track rearranged | [Starter implementations](#starter-implementations); [Multiple file submissions](#multiple-file-submissions) |
 | New issue observed in track | [Good first patches](#good-first-patches) |
 | "Good first patch" issue completed | [Good first patches](#good-first-patches) |
@@ -46,7 +46,33 @@ References: [[1](https://github.com/exercism/java/issues/178)], [[2](https://git
 ### Adhere to best practices
 
 > Ensure that all Java code adheres to the best practices listed below:
-> - minimize the accessibility of classes and members ([Effective Java, item 13](http://jtechies.blogspot.com/2012/07/item-13-minimize-accessibility-of.html))
+> - Minimize the accessibility of classes and members ([Effective Java, item 13](http://jtechies.blogspot.com/2012/07/item-13-minimize-accessibility-of.html))
+> - Always use curly brackest in if statements. This makes your code easier to maintain and easier to read ([Oracle style guide, item 7.4](http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-142311.html#431))
+```java
+// Please do this
+if (condition) {
+    doSomething();
+}
+
+// Please don't do this
+if (condition)
+    doSomething();
+
+if (condition) doSomething();
+```
+> - Always put opening curly bracket not on a newline ([Oracle style guide, item 7.2](http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-142311.html#431))
+```java
+// Please do this
+for (int i = 0; i < 10; i++) {
+    ...
+}
+
+// Please don't do this
+for (int i = 0; i < 10; i++)
+{
+    ...
+}
+```
 
 ### Ignore noninitial tests
 
@@ -74,7 +100,7 @@ References: [[1](https://github.com/exercism/java/issues/395#issue-215734887)]
 
 ### Name test class after class under test
 
-> If you're testing a class called `SomeClassName` then your test class should be called `SomeClassNameTest`. 
+> If you're testing a class called `SomeClassName` then your test class should be called `SomeClassNameTest`.
 
 > The exception to this is if the tests are split into several test classes where each test class tests different functionality. In that case each class should be named `SomeClassNameFunctionalityTest` where `Functionality` is the name of the functionality to be tested in that class. See the [clock exercise](https://github.com/exercism/java/tree/master/exercises/clock) as an example.
 
@@ -93,3 +119,42 @@ References: [[1](https://github.com/exercism/java/issues/697)]
 > We add the file to every exercise with difficulty 5 because the structure of the track means that we don't know which exercise will be the first one without starter implementation that a user will be faced with.
 
 References: [[1](https://github.com/exercism/java/issues/1075)]
+
+### Reference tutorial in the first exercises
+
+> The hello world exercise has an extensive tutorial on how to solve exercism exercises.
+> This tutorial would probably be useful to have as a reference when solving some of the other earlier exercises as well.
+> Therefore any exercise with difficulty less than 3 should have a hints.md file which references [the hello world tutorial](https://github.com/exercism/java/blob/master/exercises/hello-world/TUTORIAL.md).
+
+References: [[1](https://github.com/exercism/java/issues/1389)]
+
+### Avoid returning null
+
+> The [canonical data](https://github.com/exercism/problem-specifications/tree/master/exercises) for each exercise intentionally doesn't deal with error handling.
+> When an error has occured or a method can't return anything, the canonical data will just mark that as `"expected": null`.
+> This is because error handling varies from language to language, so the canonical data is leaving it up to each language track to decide how to deal with those situations.
+> It doesn't mean that the method needs to return `null`.
+
+> In Java it's considered bad practice to return `null`.
+> If you return `null` then the user of the method has to remember to check for `null` and they have to look at the implementation of the method to find out that this is necessary.
+
+> It's considered best practice to deal with errors and unexpected circumstances by throwing exceptions.
+> If you throw an exception then you force the user to deal with the problem.
+> You can either define your own exception (see [the triangle exercise](https://github.com/exercism/java/blob/master/exercises/triangle/.meta/src/reference/java/TriangleException.java) for an example) or use a predefined one (see [the collatz-conjecture exercise](https://github.com/exercism/java/blob/master/exercises/collatz-conjecture/src/test/java/CollatzCalculatorTest.java) for an example).
+
+> Another option is to use [Optionals](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html).
+> This can be more suitable if the case you want to deal with isn't an exceptional occurence, but rather an expected scenario, e.g. a search method not finding what it was searching for.
+> See [the word-search exercise](https://github.com/exercism/java/blob/master/exercises/word-search/src/test/java/WordSearcherTest.java) for an example where `Optional` is used.
+
+References: [[1](https://www.codebyamir.com/blog/stop-returning-null-in-java)]
+
+### Use ExceptedException
+
+> Some exercises expect exceptions to be thrown in the tests.
+> The exercises on this track are all using JUnit's [`ExpectedException`](http://junit.org/junit4/javadoc/4.12/org/junit/rules/ExpectedException.html) `@Rule` feature to support that instead of `@Test(expected = SomeException.class)`.
+> `ExpectedException` is more powerful than using the `@Test` annotation, since with `ExpectedException` you can also inspect the exception's error message and other properties.
+> To be consistent, please use `ExpectedException` whenever you expect an exception to be thrown.
+
+> See [the triangle tests](https://github.com/exercism/java/blob/master/exercises/triangle/src/test/java/TriangleTest.java) for an example of where `ExpectedException` is used.
+
+References: [[1](https://github.com/junit-team/junit4/wiki/Exception-testing)]

data/tracks/java/exercises/crypto-square/README.md

@@ -45,11 +45,10 @@ The message above is coded as:
 imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau
 ```
 
-Output the encoded text in chunks.  Phrases that fill perfect rectangles
-`(r X c)` should be output `c` chunks of `r` length, separated by spaces.
-Phrases that do not fill perfect rectangles will have `n` empty spaces.
-Those spaces should be distributed evenly, added to the end of the last
-`n` chunks.
+Output the encoded text in chunks that fill perfect rectangles `(r X c)`,
+with `c` chunks of `r` length, separated by spaces. For phrases that are
+`n` characters short of the perfect rectangle, pad each of the last `n`
+chunks with a single trailing space.
 
 ```text
 imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau 

data/tracks/java/exercises/error-handling/README.md

@@ -9,6 +9,44 @@ This exercise requires you to handle various errors. Because error handling
 is rather programming language specific you'll have to refer to the tests
 for your track to see what's exactly required.
 
+# Java Tips
+
+This exercise requires you to handle exceptions. An [exception](https://docs.oracle.com/javase/tutorial/essential/exceptions/definition.html) is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.
+
+In Java, there are two types of exceptions: checked and unchecked exceptions.
+
+- [Checked vs Unchecked Exceptions in Java](https://www.geeksforgeeks.org/checked-vs-unchecked-exceptions-in-java/)
+
+- [Unchecked Exceptions — The Controversy](https://docs.oracle.com/javase/tutorial/essential/exceptions/runtime.html)
+
+## Checked exceptions
+
+Checked exceptions are the exceptions that are checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of any method that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) a checked exception and handle or rethrow them when calling any method that can throw a checked exception.
+
+This is because checked exceptions are meant to be handled at runtime, i.e. they are errors you can recover from.
+
+### Examples of where they are used
+
+They're often used when a method can't return any valid result, for example a search method which hasn't found the item it was searching for.
+
+It's an alternative to returning null or a error code. A checked exception is better than those alternatives because it forces the user of the method to consider the error case.
+
+## Unchecked exceptions
+
+Unchecked exceptions are the exceptions that are not checked at [compile time](https://en.wikipedia.org/wiki/Compile_time).
+
+### Practical implications
+
+You don't have to declare them in the [method signature](https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html) of methods that can [throw](https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html) an unchecked exception and handle or rethrow them when calling any method that can throw an unchecked exception.
+
+### Examples of where they are used
+
+Unchecked exceptions are mean to be used for any error than can't be handled at runtime, e.g. running out of memory.
+
 # Running the tests
 
 You can run all the tests for an exercise by entering

data/tracks/java/exercises/series/README.md

@@ -1,18 +1,18 @@
 # Series
 
 Given a string of digits, output all the contiguous substrings of length `n` in
-that string.
+that string in the order that they appear.
 
 For example, the string "49142" has the following 3-digit series:
 
-- 491
-- 914
-- 142
+- "491"
+- "914"
+- "142"
 
 And the following 4-digit series:
 
-- 4914
-- 9142
+- "4914"
+- "9142"
 
 And if you ask for a 6-digit series from a 5-digit string, you deserve
 whatever you get.

data/tracks/java/exercises/sieve/README.md

@@ -5,8 +5,8 @@ number.
 
 The Sieve of Eratosthenes is a simple, ancient algorithm for finding all
 prime numbers up to any given limit. It does so by iteratively marking as
-composite (i.e. not prime) the multiples of each prime,
-starting with the multiples of 2.
+composite (i.e. not prime) the multiples of each prime, starting with the
+multiples of 2. It does not use any division or remainder operation.
 
 Create your range, starting at two and continuing up to and including the given limit. (i.e. [2, limit])
 
@@ -25,7 +25,9 @@ https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
 
 Notice that this is a very specific algorithm, and the tests don't check
 that you've implemented the algorithm, only that you've come up with the
-correct list of primes.
+correct list of primes. A good first test is to check that you do not use
+division or remainder operations (div, /, mod or % depending on the
+language).
 
 # Running the tests
 

data/tracks/java/scripts/canonical_data_check.sh

@@ -93,7 +93,7 @@ do
         continue
     fi
 
-    track_data_version=$(cat $track_exercise_version_file_path)
+    track_data_version=$(cat $track_exercise_version_file_path | sed 's/\r$//')
 
     if [ "$track_data_version" = "$canonical_data_version" ]
     then

data/tracks/python/exercises/react/example.py

@@ -1,65 +1,56 @@
 class Cell(object):
-    def __init__(self, reactor, value=0, dependencies=set(),
-                 updater=None):
-        self.reactor = reactor
-        self.index = len(reactor.cells)
-        reactor.cells.append(self)
-        self.value = value
-        self.dirty = False
-        self.dependencies = dependencies
-        self.dependents = set()
-        self.updater = updater
-        self.watchers = set()
-        if updater is not None:
-            self.update()
-            self.notify()
-
-    def add_watcher(self, watcher):
-        self.watchers.add(watcher)
-
-    def remove_watcher(self, watcher):
-        self.watchers.remove(watcher)
-
-    def set_value(self, value, top=True):
-        self.value = value
-        for d in self.dependents:
-            d.update()
-        if top:
-            self.reactor.notify()
-
-    def update(self):
-        if self.updater is not None:
-            values = [d.value for d in self.dependencies]
-            value = self.updater(values)
-            if self.value != value:
-                self.set_value(value, False)
-                self.dirty = True
-
-    def notify(self):
-        if self.dirty:
-            for watcher in self.watchers:
-                watcher(self, self.value)
-            self.dirty = False
-
-    def __hash__(self):
-        return self.index
-
-
-class Reactor(object):
     def __init__(self):
-        self.cells = []
-
-    def create_input_cell(self, value):
-        return Cell(self, value=value)
-
-    def create_compute_cell(self, dependencies, updater):
-        cell = Cell(self,
-                    dependencies=dependencies,
-                    updater=updater)
-        for d in dependencies:
-            d.dependents.add(cell)
-        return cell
-
-    def notify(self):
-        for cell in self.cells:
-            cell.notify()
+        self._watchers = []
+        self._value = None
+        self.counter = 0
+
+    def add_watcher(self, cell):
+        self._watchers.append(cell)
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, new_value):
+        self._value = new_value
+        self.counter += 1
+        for cell in self._watchers:
+            cell.compute()
+
+
+class InputCell(Cell):
+    def __init__(self, initial_value):
+        super(InputCell, self).__init__()
+        self._value = initial_value
+
+
+class ComputeCell(Cell):
+    def __init__(self, inputs, compute_function):
+        super(ComputeCell, self).__init__()
+        self.inputs = inputs
+        self.func = compute_function
+        self.callbacks = set()
+        self.compute()
+        self._register_inputs()
+
+    def _register_inputs(self):
+        for inp in self.inputs:
+            inp.add_watcher(self)
+
+    def compute(self):
+        # Only compute this cell when all inputs have same counters
+        if len(set([inp.counter for inp in self.inputs])) > 1:
+            return
+        new_val = self.func([inp.value for inp in self.inputs])
+        if new_val != self._value:
+            self.value = new_val
+            for cb in self.callbacks:
+                cb(new_val)
+
+    def add_callback(self, callback):
+        self.callbacks.add(callback)
+
+    def remove_callback(self, callback):
+        if callback in self.callbacks:
+            self.callbacks.remove(callback)