trackler 2.2.1.10 → 2.2.1.11

data/tracks/java/exercises/minesweeper/src/example/java/MinesweeperBoard.java

@@ -30,13 +30,13 @@ final class MinesweeperBoard {
     }
 
     private String getRowWithNumbers(final int rowNumber) {
-        String result = "";
+        StringBuilder result = new StringBuilder(numberOfColumns);
 
         for (int columnNumber = 0; columnNumber < numberOfColumns; columnNumber++) {
-            result += getCellNumber(rowNumber, columnNumber);
+            result.append(getCellNumber(rowNumber, columnNumber));
         }
 
-        return result;
+        return result.toString();
     }
 
     private char getCellNumber(final int rowNumber, final int columnNumber) {

data/tracks/java/exercises/series/src/test/java/SeriesTest.java

@@ -1,4 +1,5 @@
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import org.junit.Test;
@@ -63,11 +64,11 @@ public class SeriesTest {
     public void canSliceByOne() {
         Series series = new Series("01234");
         List<List<Integer>> expected = Arrays.asList(
-                Arrays.asList(0),
-                Arrays.asList(1),
-                Arrays.asList(2),
-                Arrays.asList(3),
-                Arrays.asList(4)
+		 Collections.singletonList(0),
+                Collections.singletonList(1),
+                Collections.singletonList(2),
+                Collections.singletonList(3),
+                Collections.singletonList(4)
         );
         List<List<Integer>> actual = series.slices(1);
         assertNotNull(actual);

data/tracks/java/exercises/settings.gradle

@@ -31,6 +31,7 @@ include 'grade-school'
 include 'hamming'
 include 'hexadecimal'
 include 'hello-world'
+include 'house'
 include 'isogram'
 include 'kindergarten-garden'
 include 'largest-series-product'

data/tracks/java/exercises/two-fer/src/test/java/TwoferTest.java

@@ -38,4 +38,13 @@ public class TwoferTest {
 
         assertEquals(expected, twofer.twofer(input));
     }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void emptyStringGiven() {
+        String input = "";
+        String expected = "One for , one for me.";
+
+        assertEquals(expected, twofer.twofer(input) );
+    }
 }

data/tracks/javascript/exercises/circular-buffer/circular-buffer.spec.js

@@ -109,4 +109,12 @@ describe('CircularBuffer', function() {
     expect(buffer.read).toThrow(bufferEmptyException());
   });
 
+  xit('multiple buffers don\'t interfere with each other', function() {
+    var buffer1 = circularBuffer(1);
+    var buffer2 = circularBuffer(1);
+    buffer1.write('1');
+    expect(buffer2.read).toThrow(bufferEmptyException());
+    expect(buffer1.read()).toBe('1');
+  });
+
 });

data/tracks/javascript/exercises/simple-cipher/README.md

@@ -47,7 +47,7 @@ Given the key "aaaaaaaaaaaaaaaaaa", encoding the string "iamapandabear"
 would return the original "iamapandabear".
 
 Given the key "ddddddddddddddddd", encoding our string "iamapandabear"
-would return the obscured "lpdsdqgdehdu"
+would return the obscured "ldpdsdqgdehdu"
 
 In the example above, we've set a = 0 for the key value. So when the
 plaintext is added to the key, we end up with the same message coming

data/tracks/kotlin/docs/ABOUT.md

@@ -1,15 +1,12 @@
-Why Kotlin
--------------
 Kotlin was designed and developed by JetBrains, the company behind IntelliJ. 
-It is a language that runs on the JVM which can target versions 6+ (including the Android platform).
-JetBrains wanted to use a statically typed language which can remove Java boilerplate code, 
-provide modern functional paradigms, and had seamless two-way Java interoperability with their existing codebase.
-The JVM already had alternate languages like Groovy and Scala but neither fit the bill with their desired criteria,
-so they built Kotlin.
+It is a language that runs on the JVM which can target versions 6+ (including the Android platform). 
+JetBrains wanted to use a statically typed language which can remove Java boilerplate code, provide modern functional paradigms, and had seamless two-way Java interoperability with their existing codebase. 
+The JVM already had alternate languages like Groovy and Scala but neither fit the bill with their desired criteria, so they built Kotlin.
 
 Kotlin syntax is similar to Scala and Swift but pulls in the best-of-breed features from other languages such as
-C# and Groovy. Kotlin took a pragmatic approach at features included in the language by only providing functionality that has
-been proven to be useful for developers. With this decision they implemented a subset of features of Scala with the intent 
-that it will provide more maintainable code with an easier learning curve for developers looking for a "better Java".
+C# and Groovy. 
+Kotlin took a pragmatic approach at features included in the language by only providing functionality that has
+been proven to be useful for developers. 
+With this decision they implemented a subset of features of Scala with the intent that it will provide more maintainable code with an easier learning curve for developers looking for a "better Java".
 
 JetBrains has a dedicated team of developers working on Kotlin with the codebase available on [Github](https://github.com/JetBrains/kotlin).

data/tracks/lisp/.travis.yml

@@ -1,28 +1,43 @@
 ---
-language: lisp
+language: common-lisp
+sudo: false
+
+addons:
+  apt:
+    packages:
+      - libc6-i386
+      - openjdk-7-jre
 
 env:
+  global:
+    - PATH=~/.roswell/bin:$PATH
+    - ROSWELL_INSTALL_DIR=$HOME/.roswell
   matrix:
-    - LISP=sbcl-bin
-    - LISP=ccl-bin
-    - LISP=ecl
-    # - LISP=clisp
+    - LISP=sbcl
     - LISP=abcl-bin
     - LISP=allegro
-    # - LISP=clasp
-    # - LISP=cmu-bin
+    - LISP=ccl-bin
+    - LISP=ecl
+    - LISP=clasp
+    - LISP=clisp
+    - LISP=cmu-bin
+    #- LISP=sbcl-bin
 
 matrix:
   fast_finish: true
   allow_failures:
-    - env: LISP=abcl-bin
-    - env: LISP=allegro
-    # - env: LISP=cmu-bin
-    # - env: LISP=clasp
+    - env: LISP=clasp
+    - env: LISP=clisp
+    - env: LISP=cmu-bin
 
 install:
   - curl -L 'https://raw.githubusercontent.com/snmsts/roswell/release/scripts/install-for-ci.sh' | sh
 
+cache:
+  directories:
+    - $HOME/.roswell
+    - $HOME/.config/common-lisp
+
 before_script:
   - bin/fetch-configlet
   - bin/configlet lint .

data/tracks/purescript/docs/ABOUT.md

@@ -0,0 +1,16 @@
+PureScript is a purely functional, statically-typed programming language with
+type inference.
+
+**Functional** means that functions are first-class data types.
+
+**Purely Functional** means (roughly) that there are no side effects.
+Every function will always return the same value for a given argument
+and will do nothing else.
+
+**Statically-typed** means that identifiers have a type set at compile
+time--like those in Java, C++ or C#--instead of holding data of any
+type like those in Python, Ruby or JavaScript.
+
+**Type inference** means that the compiler will often figure out the
+type of an identifier by itself so you don't have to specify it.
+Scala and later versions of C# both do this.

data/tracks/r/config.json

@@ -1,7 +1,7 @@
 {
   "language": "R",
-  "checklist_issue": 5,
   "active": true,
+  "blurb": "R is an interpreted, open source programming language with powerful data manipulation and graphical capabilities. It has a thriving package ecosystem and is one of the most popular languages for data science.",
   "foregone": [
 
   ],

data/tracks/r/config/maintainers.json

@@ -2,22 +2,22 @@
   "maintainers": [
     {
       "github_username": "jonmcalder",
-      "show_on_website": false,
+      "show_on_website": true,
       "alumnus": false,
-      "name": null,
-      "bio": null,
-      "link_text": null,
-      "link_url": null,
+      "name": "Jon Calder",
+      "bio": "I was introduced to R during my statistics undergrad in 2006 and have been trying to learn to use it properly ever since! I love the power, flexibility and expressiveness of the language, and hope I can help others to appreciate it too.",
+      "link_text": "My Website",
+      "link_url": "http://joncalder.co.za",
       "avatar_url": null
     },
     {
       "github_username": "katrinleinweber",
-      "show_on_website": false,
+      "show_on_website": true,
       "alumnus": false,
       "name": null,
-      "bio": null,
-      "link_text": null,
-      "link_url": null,
+      "bio": "I struggled to apply R to my own PhD research data in 2013. A Science Craft grad school course finally got me started when I decided to use another, well-formated data set. Since then, I have found R to be a lifeline for data analysis and teaching myself and others one or the other programming skill :-)   R may not be pretty, but it gets the job done.",
+      "link_text": "KonScience podcast (mostly German)",
+      "link_url": "www.konscience.de/archiv/recorded-talks/",
       "avatar_url": null
     },
     {

data/tracks/r/docs/ABOUT.md

@@ -1,14 +1,12 @@
-R is a free, open source, programming language and software environment for statistical computing and graphics developed at Bell Laboratories as a GNU project. It is designed as a true computer language, and is written in C, Fortran and R.
+R is an open source, programming *lingua franca* of statistics. 
+It was created by **R**oss Ihaka and **R**obert Gentleman at the University of Auckland, who wanted a language that was better suited to statistical computing and easier to use than comparable software designed by computer scientists.
 
-R provides a wide variety of statistical (linear and nonlinear modelling, classical statistical tests, time-series analysis, classification, clustering, etc) and graphical techniques, and is highly extensible.
+In addition to being a programming language, R is also an environment for interactive data analysis. 
+Its powerful metaprogramming capabilities allow for magically succinct and concise functions. 
+It can also integrate with high-performance programming languages like Fortran, C, and C++. 
+These combined attributes provide an excellent environment for designing [domain-specific languages](https://en.wikipedia.org/wiki/Domain-specific_language).
 
-One of its strengths is the ease with which well-designed publication-quality plots can be produced, including mathematical symbols and formulae where needed. Great care has been taken over the defaults for the minor design choices in graphics, but the user retains full control. Along with this, for computationally-intensive tasks, C, C++ and Fortran can be linked and called at runtime or one can even write C code to manipulate R objects directly.
+Ross Ihaka describes R as "a real demonstration of the power of collaboration". 
+R has a fantastic community of both users and developers, who contribute to a massive (and rapidly growing) collection of [packages](https://cran.r-project.org/) for importing, manipulating and visualising data, as well as cutting edge methods for statistical modelling and machine learning.
 
-The R software suite includes:
-* An effective data handling and storage facility,
-* A suite of operators for calculations on arrays, in particular matrices,
-* A large, coherent, integrated collection of intermediate tools for data analysis,
-* graphical facilities for data analysis and display either on-screen or on hardcopy, and
-* A well-developed, simple and effective programming language which includes conditionals, loops, user-defined recursive functions and input and output facilities.
-* The term “environment” is intended to characterize it as a fully planned and coherent system, rather than an incremental accretion of very specific and inflexible tools, as is frequently the case with other data analysis software.
-* R can be extended (easily) via packages. There are about eight packages supplied with the R distribution and many more are available through the CRAN family of Internet sites covering a very wide range of modern statistics.
+Learn more on [r-project.org](https://www.r-project.org/)!

data/tracks/r/docs/snippet.txt

@@ -0,0 +1,10 @@
+collatz <- function(num) {
+  if (num <= 0)
+    stop("num must be positive")
+  else if (num == 1)
+    return(0)
+  else if (num %% 2 == 0)
+    return(1 + collatz(num / 2))
+  else
+    return(1 + collatz(3 * num + 1))
+}

data/tracks/ruby/docs/ABOUT.md

@@ -1,11 +1,11 @@
-Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.
+Ruby is a dynamic, open source programming language with a focus on simplicity and productivity.
+It has an elegant syntax that is natural to read and easy to write.
 
-Ruby was created as a language of careful balance. Its creator, [Yukihiro “Matz” Matsumoto](https://en.wikipedia.org/wiki/Yukihiro_Matsumoto), blended parts of his favorite languages (Perl, Smalltalk, Eiffel, Ada, and Lisp) to form a new language that balanced functional programming with imperative programming.
+Ruby was created as a language of careful balance.
+Its creator, [Yukihiro “Matz” Matsumoto](https://en.wikipedia.org/wiki/Yukihiro_Matsumoto), blended parts of his favorite languages (Perl, Smalltalk, Eiffel, Ada, and Lisp) to form a new language that balanced functional programming with imperative programming.
 
 He has often said that he is "trying to make Ruby natural, not simple," in a way that mirrors life.
 
-Building on this, he adds:
-
-> Ruby is simple in appearance, but is very complex inside, just like our human body.
+Building on this, he adds: "Ruby is simple in appearance, but is very complex inside, just like our human body."
 
 You can read more about the Ruby language [on its site](https://www.ruby-lang.org/en/about/).

data/tracks/ruby/exercises/collatz-conjecture/.meta/generator/collatz_conjecture_case.rb

@@ -1,7 +1,6 @@
 require 'generator/exercise_case'
 
 class CollatzConjectureCase < Generator::ExerciseCase
-  using Generator::Underscore
 
   def workload
     case expected
@@ -25,7 +24,7 @@ class CollatzConjectureCase < Generator::ExerciseCase
   end
 
   def input
-    number.underscore
+    literal(number)
   end
 end
 

data/tracks/ruby/exercises/space-age/.meta/generator/space_age_case.rb

@@ -1,10 +1,9 @@
 require 'generator/exercise_case'
 
 class SpaceAgeCase < Generator::ExerciseCase
-  using Generator::Underscore
 
   def workload
-    indent_lines(["age = SpaceAge.new(#{seconds.underscore})",
+    indent_lines(["age = SpaceAge.new(#{literal(seconds)})",
       "assert_in_delta #{expected}, age.on_#{planet.downcase}, DELTA"
     ], 4)
   end

data/tracks/ruby/exercises/sum-of-multiples/.meta/generator/sum_of_multiples_case.rb

@@ -4,7 +4,7 @@ class SumOfMultiplesCase < Generator::ExerciseCase
   using Generator::Underscore
 
   def workload
-    assert_expected = "assert_equal #{expected.underscore}"
+    assert_expected = "assert_equal #{underscore(expected)}"
     value = "SumOfMultiples.new(#{factors.join(', ')}).to(#{limit})"
     indent_lines(["#{assert_expected}, #{value}"], 4)
   end

data/tracks/ruby/lib/generator/exercise_case.rb

@@ -27,5 +27,20 @@ module Generator
     def respond_to?(sym, include_private = false)
       canonical.respond_to?(sym) || super
     end
+
+    protected
+
+    def literal(number)
+      number.underscore
+    end
+
+    def underscore(string)
+      string.underscore
+    end
+
+    def camel_case(string)
+      string.camel_case
+    end
+
   end
 end

data/tracks/scala/exercises/alphametics/src/test/scala/AlphameticsTest.scala

@@ -1,9 +1,12 @@
-import org.scalatest.{FunSuite, Matchers}
+import org.scalatest.{Matchers, FunSuite}
 
+/** @version 1.0.0 */
 class AlphameticsTest extends FunSuite with Matchers {
+
   test("puzzle with three letters") {
-    Alphametics.solve("I + BB == ILL") should
-      be (Some(Map('I' -> 1, 'B' -> 9, 'L' -> 0)))
+    Alphametics.solve("I + BB == ILL") should be (Some(Map('B' -> 9,
+      'I' -> 1,
+      'L' -> 0)))
   }
 
   test("solution must have unique value for each letter") {
@@ -18,45 +21,56 @@ class AlphameticsTest extends FunSuite with Matchers {
 
   test("puzzle with four letters") {
     pending
-    Alphametics.solve("AS + A == MOM") should
-      be (Some(Map('A' -> 9, 'S' -> 2, 'M' -> 1, 'O' -> 0)))
+    Alphametics.solve("AS + A == MOM") should be (Some(Map('A' -> 9,
+      'M' -> 1,
+      'O' -> 0,
+      'S' -> 2)))
   }
 
   test("puzzle with six letters") {
     pending
-    Alphametics.solve("NO + NO + TOO == LATE") should
-      be (Some(Map('N' -> 7, 'O' -> 4, 'T' -> 9, 'L' -> 1, 'A' -> 0, 'E' -> 2)))
+    Alphametics.solve("NO + NO + TOO == LATE") should be (Some(Map('A' -> 0,
+      'E' -> 2,
+      'L' -> 1,
+      'N' -> 7,
+      'O' -> 4,
+      'T' -> 9)))
   }
 
   test("puzzle with seven letters") {
     pending
-    Alphametics.solve("HE + SEES + THE == LIGHT") should
-      be (Some(Map('E' -> 4, 'G' -> 2, 'H' -> 5, 'I' -> 0, 'L' -> 1, 'S' -> 9, 'T' -> 7)))
+    Alphametics.solve("HE + SEES + THE == LIGHT") should be (Some(Map('E' -> 4,
+      'G' -> 2,
+      'H' -> 5,
+      'I' -> 0,
+      'L' -> 1,
+      'S' -> 9,
+      'T' -> 7)))
   }
 
   test("puzzle with eight letters") {
     pending
-    Alphametics.solve("SEND + MORE == MONEY") should
-      be (Some(Map('S' -> 9, 'E' -> 5, 'N' -> 6, 'D' -> 7, 'M' -> 1,
-            'O' -> 0, 'R' -> 8, 'Y' -> 2)))
+    Alphametics.solve("SEND + MORE == MONEY") should be (Some(Map('D' -> 7,
+      'E' -> 5,
+      'M' -> 1,
+      'N' -> 6,
+      'O' -> 0,
+      'R' -> 8,
+      'S' -> 9,
+      'Y' -> 2)))
   }
 
   test("puzzle with ten letters") {
     pending
-    Alphametics.solve("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE") should
-      be (Some(Map('A' -> 5, 'D' -> 3, 'E' -> 4, 'F' -> 7, 'G' -> 8,
-            'N' -> 0, 'O' -> 2, 'R' -> 1, 'S' -> 6, 'T' -> 9)))
-  }
-
-  test("solve puzzle with multiplication") {
-    pending
-    Alphametics.solve("IF * DR == DORI") should
-      be (Some(Map('I' -> 8, 'F' -> 2, 'D' -> 3, 'R' -> 9, 'O' -> 1)))
-  }
-
-  test("solve puzzle with exponents") {
-    pending
-    Alphametics.solve("PI * R ^ 2 == AREA") should
-      be (Some(Map('P' -> 9, 'I' -> 6, 'R' -> 7, 'A' -> 4, 'E' -> 0)))
+    Alphametics.solve("AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE") should be (Some(Map('A' -> 5,
+      'D' -> 3,
+      'E' -> 4,
+      'F' -> 7,
+      'G' -> 8,
+      'N' -> 0,
+      'O' -> 2,
+      'R' -> 1,
+      'S' -> 6,
+      'T' -> 9)))
   }
-}
+}