trackler 2.0.6.17 → 2.0.6.18

data/tracks/fsharp/exercises/linked-list/LinkedListTest.fs

@@ -4,6 +4,14 @@ open NUnit.Framework
 open LinkedList
 
 [<Test>]
+let ``Pop returns None if the list is empty`` () =
+    let linkedList = mkLinkedList ()
+    let value = pop linkedList
+
+    Assert.That(value, Is.EqualTo(None))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
 let ``Push and pop are first in last out order`` () =
     let linkedList = mkLinkedList ()
     linkedList |> push 10
@@ -12,8 +20,16 @@ let ``Push and pop are first in last out order`` () =
     let val1 = pop linkedList
     let val2 = pop linkedList
 
-    Assert.That(val1, Is.EqualTo(20))
-    Assert.That(val2, Is.EqualTo(10))
+    Assert.That(val1, Is.EqualTo(Some 20))
+    Assert.That(val2, Is.EqualTo(Some 10))
+
+[<Test>]
+[<Ignore("Remove to run test")>]
+let ``Shift returns None if the list is empty`` () =
+    let linkedList = mkLinkedList ()
+    let value = shift linkedList
+
+    Assert.That(value, Is.EqualTo(None))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
@@ -25,8 +41,8 @@ let ``Push and shift are first in first out order`` () =
     let val1 = shift linkedList
     let val2 = shift linkedList
 
-    Assert.That(val1, Is.EqualTo(10))
-    Assert.That(val2, Is.EqualTo(20))
+    Assert.That(val1, Is.EqualTo(Some 10))
+    Assert.That(val2, Is.EqualTo(Some 20))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
@@ -38,8 +54,8 @@ let ``Unshift and shift are last in first out order`` () =
     let val1 = shift linkedList
     let val2 = shift linkedList
 
-    Assert.That(val1, Is.EqualTo(20))
-    Assert.That(val2, Is.EqualTo(10))
+    Assert.That(val1, Is.EqualTo(Some 20))
+    Assert.That(val2, Is.EqualTo(Some 10))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
@@ -51,8 +67,8 @@ let ``Unshift and pop are last in last out order`` () =
     let val1 = pop linkedList
     let val2 = pop linkedList
 
-    Assert.That(val1, Is.EqualTo(10))
-    Assert.That(val2, Is.EqualTo(20))
+    Assert.That(val1, Is.EqualTo(Some 10))
+    Assert.That(val2, Is.EqualTo(Some 20))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
@@ -66,9 +82,9 @@ let ``Push and pop can handle multiple values`` () =
     let val2 = pop linkedList
     let val3 = pop linkedList
 
-    Assert.That(val1, Is.EqualTo(30))
-    Assert.That(val2, Is.EqualTo(20))
-    Assert.That(val3, Is.EqualTo(10))
+    Assert.That(val1, Is.EqualTo(Some 30))
+    Assert.That(val2, Is.EqualTo(Some 20))
+    Assert.That(val3, Is.EqualTo(Some 10))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
@@ -82,9 +98,9 @@ let ``Unshift and shift can handle multiple values`` () =
     let val2 = shift linkedList
     let val3 = shift linkedList
 
-    Assert.That(val1, Is.EqualTo(30))
-    Assert.That(val2, Is.EqualTo(20))
-    Assert.That(val3, Is.EqualTo(10))
+    Assert.That(val1, Is.EqualTo(Some 30))
+    Assert.That(val2, Is.EqualTo(Some 20))
+    Assert.That(val3, Is.EqualTo(Some 10))
 
 [<Test>]
 [<Ignore("Remove to run test")>]
@@ -95,12 +111,12 @@ let ``All methods of manipulating the linkedList can be used together`` () =
 
     let val1 = pop linkedList
 
-    Assert.That(val1, Is.EqualTo(20))
+    Assert.That(val1, Is.EqualTo(Some 20))
 
     linkedList |> push 30
     let val2 = shift linkedList
 
-    Assert.That(val2, Is.EqualTo(10))
+    Assert.That(val2, Is.EqualTo(Some 10))
 
     linkedList |> unshift 40
     linkedList |> push 50
@@ -109,6 +125,6 @@ let ``All methods of manipulating the linkedList can be used together`` () =
     let val4 = pop linkedList
     let val5 = shift linkedList
 
-    Assert.That(val3, Is.EqualTo(40))
-    Assert.That(val4, Is.EqualTo(50))
-    Assert.That(val5, Is.EqualTo(30))
+    Assert.That(val3, Is.EqualTo(Some 40))
+    Assert.That(val4, Is.EqualTo(Some 50))
+    Assert.That(val5, Is.EqualTo(Some 30))

data/tracks/groovy/docs/ABOUT.md

@@ -1,14 +1,9 @@
-[Groovy](http://www.groovy-lang.org/), initially released in 2007, is a dynamic object-oriented programming language based on Java.
+[Groovy](http://www.groovy-lang.org/) is the Apache Foundation's powerful, optionally typed, dynamic language, which also features static-typing and static compilation capabilities.
 
-Groovy offers flexible and loosely typed syntax compared to Java, but still compiles down to [Java Virtual Machine](https://en.wikipedia.org/wiki/Java_virtual_machine) (JVM) [bytecode](https://en.wikipedia.org/wiki/Bytecode) and is fully interoperable with existing Java programs and libraries. 
+Groovy is aimed at improving developer productivity thanks to a concise, easy to learn syntax.  It facilitates scripting, Domain-Specific Language authoring, runtime and compile-time meta-programming, and functional programming.
 
-Some of Groovy's features include:
-  1. String interpolation, allowing static strings to include references to dynamic variables through the use of GStrings.
-  2. Closures, allowing code to be written a ran at a different time.
-  3. Flexible syntax, with semicolons, dots, and parentheses being optional in many cases.
-  4. Built in XML & JSON parsing.
-  5. [Metaprogramming](https://en.wikipedia.org/wiki/Metaprogramming).
+It allows access to the entire ecosystem of Java libraries, integrates seamlessly with Java applications.
 
-Groovy can also be used as a scripting language, similar to Python, allowing Groovy code to be executed without the need to be precompiled to class files first.
+It can be used as a simple scripting language or added to complicated Java frameworks.  It powers technologies like Gradle, Spock, Ratpack, Grails, and scripting in Jenkins.
 
-While it can be used with any existing Java framework, the [Grails Framework](https://grails.org/) provides an alternative methodology for writing JVM based web applications in Groovy.
+Also, it is fun.

data/tracks/groovy/docs/INSTALLATION.md

@@ -1,17 +1,14 @@
 ### Installation
 
-#### Installing Java
-
-In order to work with Groovy, you will also need Java. The instructions for setting up Java can be found on [Oracle](https://docs.oracle.com/javase/8/docs/technotes/guides/install/install_overview.html), but you may also want to look at the installation instructions found on the [Java Exercism](http://exercism.io/languages/java) page
-
 #### Installing Groovy
 
-Detailed installation instructions for Groovy can be found at [http://www.groovy-lang.org/install.html](http://www.groovy-lang.org/install.html).
-
-#### Install an IDE
-
-It is recommended to use an IDE for working with your Groovy exercises. It will provide code assistance, automatic compilation, and a GUI for running the tests. 
+The preferred method of installing Groovy is [SDKman](http://sdkman.io/).
 
-The community version of IntelliJ IDEA offers all the tooling you will need. Download and installation instructions can be found [here](https://www.jetbrains.com/idea/).
+Detailed instructions can be found [here](http://sdkman.io/install.html).  Breifly, open a shell and issue:
 
+1. `curl -s "https://get.sdkman.io" | bash`
+1. `source "~/.sdkman/bin/sdkman-init.sh"`
+1. `sdk install java`
+1. `sdk install groovy`
 
+Other methods of installing Groovy can be found [here](http://groovy-lang.org/install.html).

data/tracks/groovy/docs/LEARNING.md

@@ -1,8 +1,19 @@
-Interested in getting started with Groovy, or learning more while you work on exercises? 
-
-Check out some of these resources:
-* [Groovy Documentation](http://www.groovy-lang.org/documentation.html), By Dierk König, Paul King, Guillaume Laforge, Hamlet D'Arcy, Cédric Champeau, Erik Pragt, and Jon Skeet
-* [Groovy In Action](https://www.manning.com/books/groovy-in-action-second-edition)
-* [Making Java Groovy](https://www.manning.com/books/making-java-groovy), by Ken Kousen
-* [StackOverflow](http://stackoverflow.com/tags/groovy)
-* [Groovy Puzzlers](https://www.youtube.com/watch?v=GfIhxi7L6R0&list=PLwxhnQ2Qv3xuE4JEKBpyE2AbbM_7G0EN1&index=17), by Noam Tenne
+Interested in getting started with Groovy, or learning more while you work on exercises?
+
+Try out Groovy
+
+* [in a browser](https://www.jdoodle.com/execute-groovy-online)
+* opening the [Groovy Console](http://groovy-lang.org/groovyconsole.html) with `groovyConsole`
+* opening the [Groovy Shell](http://groovy-lang.org/groovyconsole.html) with `groovysh`
+
+Take a quick tour of Groovy with
+
+* Tim Rows' [Groovy Tutorial for Java Developers](https://www.timroes.de/2015/06/27/groovy-tutorial-for-java-developers/) is equally good for non-Java developers
+* [Learn X in Y minutes, Where X=Groovy ](https://learnxinyminutes.com/docs/groovy/)
+* SmartThings' [Groovy Basics](http://docs.smartthings.com/en/latest/getting-started/groovy-basics.html)
+
+Dive deeper with
+
+* the [Groovy Documentation](http://www.groovy-lang.org/documentation.html)
+* [Groovy In Action](https://www.manning.com/books/groovy-in-action-second-edition), _The Book_ on Groovy
+* Ken Kousen's [Making Java Groovy](https://www.manning.com/books/making-java-groovy)

data/tracks/groovy/docs/RESOURCES.md

@@ -1,30 +1,16 @@
-## The Groovy Language
+# Recommended Resources
 
-* [Learn Groovy](http://www.groovy-lang.org/learn.html)
-* [Groovy Documentation](http://www.groovy-lang.org/documentation.html)
+## Documentation
 
-## Unit Testing
+* the official [Groovy Language Documentation](http://docs.groovy-lang.org/docs/latest/html/documentation/)
+* Apache's [Groovy Documentation](http://www.groovy-lang.org/documentation.html), including the great [Learn Groovy](http://www.groovy-lang.org/learn.html) section
 
-* [JUnit](http://junit.org/), the de-facto standard for Java based testing.
-* [Spock](http://spockframework.github.io/spock/docs/1.0/index.html), Groovy based testing framework.
+# Tools
 
-## Frameworks
-
-* [Grails](https://grails.org/)
-* [Spring](https://spring.io/)
-
-## IDEs
-
-* [IntelliJ IDEA](https://www.jetbrains.com/idea/)
-* [Eclipse](https://eclipse.org/), with an additional plugin for Groovy language support.
-
-## Build Tools
-
-* [Gradle Docs](http://gradle.org/), an automated build tool, written in Groovy
-* [Apache Maven](https://maven.apache.org/)
-* [Gant](https://gant.github.io/)
+* [SDKman](http://sdkman.io/)
+* [Groovy Eclipse](https://github.com/groovy/groovy-eclipse/wiki)
+* [IntelliJ Idea](https://www.jetbrains.com/idea/download/)
 
 ## Collaboration
 
-* [Groovy Community](http://www.groovy-lang.org/community.html)
-
+* the [Groovy Community](http://www.groovy-lang.org/community.html) entry of the Groovy Language Documentation

data/tracks/groovy/docs/TESTS.md

@@ -1,58 +1,21 @@
-## Fetch the exercise
+## Running Tests
 
-In a Command Prompt or Terminal, fetch the first exercise.
+Execute the test specification with:
 
+```bash
+$ groovy HelloWorldSpec.groovy
 ```
-C:\Users\You>exercism fetch groovy
 
-Not Submitted:       1 problem
-groovy (Hello World) Path\To\Your\Exercism\groovy\hello-world
+## Enabling More Tests
 
-New:                 1 problem
-groovy (Hello World) Path\To\Your\Exercism\groovy\hello-world
+Once your code passes all active tests, enable another test by removing the
+`@Ignore` preceding the next test that interests you.  Do this by deleting
+the `@Ignore` line or comment it out by adding two slashes to the start of
+the line.
 
-unchanged: 0, updated: 0, new: 1
+```Groovy
+//@Ignore
+def 'outputs "Hello, Alice!" when given the name "Alice"'() {
+    expect: hello.hello('Alice') == 'Hello, Alice!'
+}
 ```
-
-## Import the exercise
-
-1) Start IntelliJ IDEA. In the "Welcome to IntelliJ IDEA" window, click the "Open" option.
-
-2) Navigate to the "Path\To\Your\Exercism\groovy\THIS_EXERCISE" folder.  Make sure you've selected the root directory of the exercise. Click "OK".
-
-3) Follow the dialog for creating the project from existing external sources.
-
-4) IntelliJ will then create a new project structure in the editor for your exercise.
-
-5) Depending on how much of the IDE you have configured before, you will likely need to add a Groovy SDK and a Java SDK (JDK 7+, ideally). These can be configured through the project/module settings by right clicking on the imported project. 
-
-6) You may also need to configure the location of the compiler output (exercism doesn't provide all IDE files since you could work the problems in a myriad of editors instead). This can be configured in the project settings as well. 
-
-## Start the exercise
-
-1) Open the `README.md` file and carefully read the background for the assignment.
-
-2) Start by running the test suite: In the "Project" view, right-click on the test file (`hello-world\HelloWorldTest.groovy`), select "Run", then pick the "HelloWorldTest" that has a JUnit icon to the left of it (red and green arrows).
-
-3) The tests are designed to fail at the beginning. Each exercise will expect you to update the associated groovy file (named the same as the test without the ````Tests```` suffix in the filename.
-
-4) To skip a test, you can add the @Ignore annotation a test method:
-
-````
-  //This test will run.
-  @Test
-  void testNoName() {
-    assertTrue new HelloWorld().hello() == 'Hello, World!'
-  }
-
-  //this test will be skipped.
-  @Test
-  @Ignore
-  void testSampleName() {
-    assertTrue new HelloWorld().hello('Alice') == 'Hello, Alice!'
-  }
-````
-
-Alternatively, you can simply comment out an entire method to have it removed from compilation and being included in test output.
-
-5) Update the main Groovy code and re-run the tests until they pass.

data/tracks/groovy/exercises/nth-prime/Example.groovy

@@ -1,19 +1,16 @@
-import groovy.transform.CompileStatic
-
-@CompileStatic
 class Prime {
 
-  private def isPrime(int n) {
+  private static def isPrime(int n) {
     def sqrt = Math.ceil(Math.sqrt(n))
     for (int i = 3; i <= sqrt; i += 1 ) {
       if ( n % i == 0 ) {
         return false
-      }  
+      }
     }
     return true
   }
 
-  def nth(int n) {
+  static nth(int n) {
     // handle stuff that doesn't need
     // additional calculations
     if ( n < 1 ) throw new ArithmeticException()

data/tracks/groovy/exercises/nth-prime/PrimeSpec.groovy

@@ -0,0 +1,27 @@
+@Grab('org.spockframework:spock-core:1.0-groovy-2.4')
+import spock.lang.*
+
+class PrimeSpec extends Specification {
+
+    def 'can calculate the first prime'() {
+        expect: Prime.nth(1) == 2
+    }
+
+    def 'can calculate the second prime'() {
+        expect: Prime.nth(2) == 3
+    }
+
+    def 'can calculate the sixth prime'() {
+        expect: Prime.nth(6) == 13
+    }
+
+    def 'can calculate a big prime'() {
+        expect: Prime.nth(10001) == 104743
+    }
+
+    def 'throws exception when asked for the zeroth prime'() {
+        when: Prime.nth(0)
+        then: thrown(ArithmeticException)
+    }
+
+}

data/tracks/java/exercises/luhn/src/example/java/LuhnValidator.java

@@ -0,0 +1,43 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+final class LuhnValidator {
+
+    private static final Pattern SPACE_PATTERN = Pattern.compile("\\s+");
+
+    boolean isValid(final String candidate) {
+        final String sanitizedCandidate = SPACE_PATTERN.matcher(candidate).replaceAll("");
+
+        final List<Integer> computedDigits = new ArrayList<>();
+
+        for (int charIndex = 0; charIndex < sanitizedCandidate.length(); charIndex++) {
+            int inputDigit = Character.digit(sanitizedCandidate.charAt(charIndex), 10);
+
+            /*
+             * Character.digit returns a negative int if the supplied character does not represent a digit with respect
+             * to the given radix.
+             */
+            if (inputDigit < 0) {
+                return false;
+            }
+
+            if (charIndex % 2 == 1) {
+                /*
+                 * Since our doubled input digit must lie in [2, 18], the operation
+                 *
+                 *   "subtract 9 from the doubled input digit if it exceeds 9 in value"
+                 *
+                 * is equivalent to applying the modulo operation below universally.
+                 */
+                inputDigit = (2 * inputDigit) % 9;
+            }
+
+            computedDigits.add(inputDigit);
+        }
+
+        final int digitSum = computedDigits.stream().mapToInt(Integer::intValue).sum();
+        return digitSum > 0 && digitSum % 10 == 0;
+    }
+
+}

data/tracks/java/exercises/luhn/src/test/java/LuhnValidatorTest.java

@@ -0,0 +1,44 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class LuhnValidatorTest {
+
+    @Test
+    public void testThatSingleDigitStringIsNotValid() {
+        assertFalse(new LuhnValidator().isValid("1"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatTheStringConsistingOfASingleZeroIsInvalid() {
+        assertFalse(new LuhnValidator().isValid("0"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatAValidCanadianSocialInsuranceNumberIsIdentifiedAsValid() {
+        assertTrue(new LuhnValidator().isValid("046 454 286"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatAnInvalidCanadianSocialInsuranceNumberIsIdentifiedAsInvalid() {
+        assertFalse(new LuhnValidator().isValid("046 454 287"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatAnInvalidCreditCardIsIdentifiedAsInvalid() {
+        assertFalse(new LuhnValidator().isValid("8273 1232 7352 0569"));
+    }
+
+    @Ignore
+    @Test
+    public void testThatAddingANonDigitCharacterToAValidStringInvalidatesTheString() {
+        assertFalse(new LuhnValidator().isValid("046a 454 286"));
+    }
+
+}