trackler 2.0.6.13 → 2.0.6.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 908196b422992f0a5116328c5efcd82340322c89
-  data.tar.gz: 88112e4cf238d4590f497bbba04f9cf21087f873
+  metadata.gz: b4773a317ee74fec5189add40d22bdb0810d4d5b
+  data.tar.gz: efb405ccd313b9bd85d8e49a64f95e73685465a0
 SHA512:
-  metadata.gz: 10fb6193269541b0dce8c9f4cd44749a83e06a251cae0a5fcae35b8edc3122aeda761754f08addc071c627c65cb0560c531254737a49b0a81dd24a523e20e1b6
-  data.tar.gz: 1d5ac6a45f0c7d9bd0c11ebf5f6abbb327b39481f3fad8195ed4bf9dafa13f6d6ef86cdd9bcad93c9330acbe4347fb28013fac11840f88df11fd93e90708270a
+  metadata.gz: df8a85473aed5805295b688533608f1bf7018764f6a030987c4a94805266c2996ea55764a039ae12f8dad321455d085af0ea5fbbf6b45f5e7b2f4756916c8506
+  data.tar.gz: a832b5beb59c5e7f4c2f72b8d6e7b0ddd681cca16fcb814d9372e98f055f36d0a8bba906e86eb97772de95ce7fab6306d8df3fcf11425d4a9b38dc58e356d9fa

data/common/TOPICS.txt

@@ -5,6 +5,7 @@ Callbacks
 Control-flow (conditionals)
 Control-flow (loops)
 Events
+Equality
 Exception handling
 Generics
 Inheritance

data/common/exercises/lens-person/metadata.yml

@@ -1,5 +1,5 @@
 ---
-blurb: "(Haskell specific) use lenses to update nested records."
+blurb: "Use lenses to update nested records (specific to languages with immutable data)."
 common:
     type: focus
     focus: lenses

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.6.13"
+  VERSION = "2.0.6.14"
 end

data/tracks/csharp/exercises/all-your-base/AllYourBaseTest.cs

@@ -131,6 +131,7 @@ public class AllYourBaseTest
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }
 
+    [Ignore("Remove to run test")]
     [Test]
     public void Negative_digit()
     {
@@ -155,7 +156,7 @@ public class AllYourBaseTest
     public void First_base_is_one()
     {
         const int inputBase = 1;
-        var inputDigits = new int[0];
+        var inputDigits = new[] { 1, 0, 1, 0, 1, 0 };
         const int outputBase = 10;
         Assert.Throws<ArgumentException>(() => Base.Rebase(inputBase, inputDigits, outputBase));
     }

data/tracks/csharp/exercises/markdown/Example.cs

@@ -14,8 +14,8 @@ public static class Markdown
     private const string ItalicMarkdown = "_";
     private const string ListItemMarkdown = "*";
 
-    private const string BoldTag = "em";
-    private const string ItalicTag = "i";
+    private const string BoldTag = "strong";
+    private const string ItalicTag = "em";
     private const string ParagraphTag = "p";
     private const string ListTag = "ul";
     private const string ListItemTag = "li";

data/tracks/csharp/exercises/markdown/Markdown.cs

@@ -14,9 +14,9 @@ public static class Markdown
         return Regex.Replace(markdown, pattern, replacement);
     }
 
-    private static string Parse__(string markdown) => Parse(markdown, "__", "em");
+    private static string Parse__(string markdown) => Parse(markdown, "__", "strong");
 
-    private static string Parse_(string markdown) => Parse(markdown, "_", "i");
+    private static string Parse_(string markdown) => Parse(markdown, "_", "em");
 
     private static string ParseText(string markdown, bool list)
     {

data/tracks/csharp/exercises/markdown/MarkdownTest.cs

@@ -14,7 +14,7 @@ public class MarkdownTest
     public void Parsing_italics()
     {
         var input = "_This will be italic_";
-        var expected = "<p><i>This will be italic</i></p>";
+        var expected = "<p><em>This will be italic</em></p>";
         Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
     }
 
@@ -22,7 +22,7 @@ public class MarkdownTest
     public void Parsing_bold_text()
     {
         var input = "__This will be bold__";
-        var expected = "<p><em>This will be bold</em></p>";
+        var expected = "<p><strong>This will be bold</strong></p>";
         Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
     }
 
@@ -30,7 +30,7 @@ public class MarkdownTest
     public void Mixed_normal_italics_and_bold_text()
     {
         var input = "This will _be_ __mixed__";
-        var expected = "<p>This will <i>be</i> <em>mixed</em></p>";
+        var expected = "<p>This will <em>be</em> <strong>mixed</strong></p>";
         Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
     }
 
@@ -70,7 +70,7 @@ public class MarkdownTest
     public void With_a_little_bit_of_everything()
     {
         var input = "# Header!\n* __Bold Item__\n* _Italic Item_";
-        var expected = "<h1>Header!</h1><ul><li><em>Bold Item</em></li><li><i>Italic Item</i></li></ul>";
+        var expected = "<h1>Header!</h1><ul><li><strong>Bold Item</strong></li><li><em>Italic Item</em></li></ul>";
         Assert.That(Markdown.Parse(input), Is.EqualTo(expected));
     }
 }

data/tracks/elixir/.travis.yml

@@ -1,10 +1,15 @@
----
 language: elixir
 elixir:
   - 1.3.2
+  - 1.4.0-rc.1
+
 otp_release:
   - 19.0
 
+matrix:
+  allow_failures:
+    - elixir: 1.4.0-rc.1
+
 script:
 - bin/fetch-configlet
 - bin/configlet .

data/tracks/go/exercises/queen-attack/example.go

@@ -2,7 +2,7 @@ package queenattack
 
 import "fmt"
 
-const testVersion = 1
+const testVersion = 2
 
 func CanQueenAttack(w, b string) (attack bool, err error) {
 	if err = valSq(w); err != nil {

data/tracks/go/exercises/queen-attack/queen_attack_test.go

@@ -5,25 +5,30 @@ import "testing"
 // Arguments to CanQueenAttack are in algebraic notation.
 // See http://en.wikipedia.org/wiki/Algebraic_notation_(chess)
 
-const targetTestVersion = 1
+const targetTestVersion = 2
 
 var tests = []struct {
 	w, b   string
 	attack bool
 	ok     bool
 }{
-	{"b4", "b4", false, false},      // same square
-	{"a8", "b9", false, false},      // off board
+	{"b4", "b4", false, false}, // same square
+	{"a8", "b9", false, false}, // off board
+	{"a0", "b1", false, false},
+	{"g3", "i5", false, false},
 	{"here", "there", false, false}, // invalid
 	{"", "", false, false},
 
 	{"b3", "d7", false, true}, // no attack
-	{"b4", "b7", true, true},  // same file
-	{"e4", "b4", true, true},  // same rank
-	{"a1", "f6", true, true},  // common diagonals
+	{"a1", "f8", false, true},
+	{"b4", "b7", true, true}, // same file
+	{"e4", "b4", true, true}, // same rank
+	{"a1", "f6", true, true}, // common diagonals
 	{"a6", "b7", true, true},
 	{"d1", "f3", true, true},
 	{"f1", "a6", true, true},
+	{"a1", "h8", true, true},
+	{"a8", "h1", true, true},
 }
 
 func TestTestVersion(t *testing.T) {

data/tracks/haskell/exercises/lens-person/examples/success-standard/package.yaml

@@ -8,7 +8,6 @@ library:
   exposed-modules: Person
   source-dirs: src
   dependencies:
-    - lens
 
 tests:
   test:

data/tracks/haskell/exercises/lens-person/examples/success-standard/src/Person.hs

@@ -1,9 +1,10 @@
-{-# LANGUAGE TemplateHaskell #-}
+{-# LANGUAGE Rank2Types #-}
 
 module Person where
 
-import           Control.Lens
-import           Data.Time.Calendar
+import Control.Applicative (Const(..), getConst)
+import Data.Functor.Identity (Identity(..), runIdentity)
+import Data.Time.Calendar (Day, toGregorian, fromGregorian)
 
 data Person = Person {
       _name    :: Name,
@@ -36,17 +37,44 @@ data Gregorian = Gregorian {
       _day   :: Int
     }
 
-makeLenses ''Person
-makeLenses ''Name
-makeLenses ''Born
-makeLenses ''Address
-makeLenses ''Gregorian
+type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t
+type Lens' s a = Lens s s a a
+type Getting s a = (a -> Const a a) -> s -> Const a s
+type Setting s t a b = (a -> Identity b) -> s -> Identity t
 
-gregorianDay :: Iso' Gregorian Day
-gregorianDay = iso toDay fromDay
-  where
-    toDay (Gregorian y m d) = fromGregorian y m d
-    fromDay d' = let (y, m, d) = toGregorian d' in Gregorian y m d
+lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
+lens sa sbt afb s = fmap (sbt s) (afb (sa s))
+
+view :: Getting s a -> s -> a
+view l = getConst . l Const
+
+over :: Setting s t a b -> (a -> b) -> s -> t
+over l f = runIdentity . l (Identity . f)
+
+set :: Setting s t a b -> b -> s -> t
+set l v = over l (const v)
+
+-- boilerplate lenses:
+
+born :: Lens' Person Born
+born = lens _born (\p b -> p { _born = b })
+
+address :: Lens' Person Address
+address = lens _address (\p a -> p { _address = a })
+
+bornAt :: Lens' Born Address
+bornAt = lens _bornAt (\b a -> b { _bornAt = a })
+
+bornOn :: Lens' Born Day
+bornOn = lens _bornOn (\b d -> b { _bornOn = d })
+
+street :: Lens' Address String
+street = lens _street (\a s -> a { _street = s })
+
+month :: Lens' Day Int
+month = lens getMonth setMonth
+  where getMonth day   = let (_, m, _) = toGregorian day in m
+        setMonth day m = let (y, _, d) = toGregorian day in fromGregorian y m d
 
 bornStreet :: Born -> String
 bornStreet = view (bornAt . street)
@@ -55,7 +83,7 @@ setCurrentStreet :: String -> Person -> Person
 setCurrentStreet = set (address . street)
 
 setBirthMonth :: Int -> Person -> Person
-setBirthMonth = set (born . bornOn . from gregorianDay . month)
+setBirthMonth = set (born . bornOn . month)
 
 renameStreets :: (String -> String) -> Person -> Person
 renameStreets f = over birthStreet f . over currentStreet f

data/tracks/java/config.json

@@ -55,7 +55,9 @@
     "wordy",
     "palindrome-products",
     "twelve-days",
-    "sublist"
+    "sublist",
+    "rectangles",
+    "matrix"
   ],
   "exercises": [
     {
@@ -317,6 +319,16 @@
       "slug": "sublist",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "rectangles",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "matrix",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

data/tracks/java/exercises/matrix/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

data/tracks/java/exercises/matrix/src/example/java/Matrix.java

@@ -0,0 +1,39 @@
+import java.util.regex.Pattern;
+
+public class Matrix {
+    private int[][] matrix;
+    private static Pattern spacePattern = Pattern.compile(" ");
+    private static Pattern newlinePattern = Pattern.compile("\\n");
+
+    public Matrix(String matrixAsString) {
+        String[] rows = newlinePattern.split(matrixAsString);
+        matrix = new int[rows.length][];
+        for (int i = 0; i < rows.length; i++) {
+            String[] columnValues = spacePattern.split(rows[i]);
+            matrix[i] = new int[columnValues.length];
+            for (int j = 0; j < columnValues.length; j++) {
+                matrix[i][j] = Integer.parseInt(columnValues[j]);
+            }
+        }
+    }
+
+    public int[] getRow(int rowNumber) {
+        return matrix[rowNumber];
+    }
+
+    public int[] getColumn(int columnNumber) {
+        int[] column = new int[matrix.length];
+        for(int i = 0; i < matrix.length; i++) {
+            column[i] = matrix[i][columnNumber];
+        }
+        return column;
+    }
+
+    public int getRowsCount() {
+        return matrix.length;
+    }
+
+    public int getColumnsCount() {
+        return matrix[0].length;
+    }
+}

data/tracks/java/exercises/matrix/src/test/java/MatrixTest.java

@@ -0,0 +1,207 @@
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.runners.Enclosed;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+@RunWith(Enclosed.class)
+public class MatrixTest {
+
+    @RunWith(Parameterized.class)
+    public static class CountRowsTest {
+        private Matrix matrix;
+        private int numberOfRows;
+
+        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \n\"{0}\" to have {1} row(s).")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", 1},
+                    {"0 1", 1},
+                    {  "0\n"
+                     + "1", 2},
+                    {  "0 1\n"
+                     + "2 3", 2},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", 3}
+            });
+        }
+
+        public CountRowsTest(String matrixAsString, int numberOfRows) {
+            this.matrix = new Matrix(matrixAsString);
+            this.numberOfRows = numberOfRows;
+        }
+
+        @Test
+        public void countRowsTest() {
+            assertEquals(numberOfRows, matrix.getRowsCount());
+        }
+    }
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class CountColumnsTest {
+        private Matrix matrix;
+        private int numberOfColumns;
+
+        @Parameterized.Parameters(name = "{index}: expected matrix constructed with string \n\"{0}\" to have {1} column(s).")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", 1},
+                    {"0 1", 2},
+                    {  "0\n"
+                     + "1", 1},
+                    {  "0 1\n"
+                     + "2 3", 2},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", 3}
+            });
+        }
+
+        public CountColumnsTest(String matrixAsString, int numberOfColumns) {
+            this.matrix = new Matrix(matrixAsString);
+            this.numberOfColumns = numberOfColumns;
+        }
+
+        @Test
+        public void countColumnsTest() {
+            assertEquals(numberOfColumns, matrix.getColumnsCount());
+        }
+    }
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class GetFirstRowTest {
+        private Matrix matrix;
+        private int[] firstRow;
+
+        @Parameterized.Parameters(name = "{index}: checking first row of matrix constructed with string \n\"{0}\".")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", new int[] {0}},
+                    {"0 1", new int[] {0, 1}},
+                    {  "0\n"
+                     + "1", new int[] {0}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {0, 1}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {0, 1, 2}}
+            });
+        }
+
+        public GetFirstRowTest(String matrixAsString, int[] firstRow) {
+            this.matrix = new Matrix(matrixAsString);
+            this.firstRow = firstRow;
+        }
+
+        @Test
+        public void getFirstRowTest() {
+            assertArrayEquals(firstRow, matrix.getRow(0));
+        }
+    }
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class GetLastRowTest {
+        private Matrix matrix;
+        private int[] lastRow;
+
+        @Parameterized.Parameters(name = "{index}: checking last row of matrix constructed with string \n\"{0}\".")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", new int[] {0}},
+                    {"0 1", new int[] {0, 1}},
+                    {  "0\n"
+                     + "1", new int[] {1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {2, 3}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {6, 7, 8}}
+            });
+        }
+
+        public GetLastRowTest(String matrixAsString, int[] lastRow) {
+            this.matrix = new Matrix(matrixAsString);
+            this.lastRow = lastRow;
+        }
+
+        @Test
+        public void getLastRowTest() {
+            assertArrayEquals(lastRow, matrix.getRow(matrix.getRowsCount() - 1));
+        }
+    }
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class GetFirstColumnTest {
+        private Matrix matrix;
+        private int[] firstColumn;
+
+        @Parameterized.Parameters(name = "{index}: checking first column of matrix constructed with string \n\"{0}\".")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", new int[] {0}},
+                    {"0 1", new int[] {0}},
+                    {  "0\n"
+                     + "1", new int[] {0, 1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {0, 2}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {0, 3, 6}}
+            });
+        }
+
+        public GetFirstColumnTest(String matrixAsString, int[] firstColumn) {
+            this.matrix = new Matrix(matrixAsString);
+            this.firstColumn = firstColumn;
+        }
+
+        @Test
+        public void getFirstColumnTest() {
+            assertArrayEquals(firstColumn, matrix.getColumn(0));
+        }
+    }
+
+
+    @Ignore
+    @RunWith(Parameterized.class)
+    public static class GetLastColumnTest {
+        private Matrix matrix;
+        private int[] lastColumn;
+
+        @Parameterized.Parameters(name = "{index}: checking last column of matrix constructed with string \n\"{0}\".")
+        public static Collection<Object[]> data() {
+            return Arrays.asList(new Object[][]{
+                    {"0", new int[] {0}},
+                    {"0 1", new int[] {1}},
+                    {  "0\n"
+                     + "1", new int[] {0, 1}},
+                    {  "0 1\n"
+                     + "2 3", new int[] {1, 3}},
+                    {  "0 1 2\n"
+                     + "3 4 5\n"
+                     + "6 7 8", new int[] {2, 5, 8}}
+            });
+        }
+
+        public GetLastColumnTest(String matrixAsString, int[] lastColumn) {
+            this.matrix = new Matrix(matrixAsString);
+            this.lastColumn = lastColumn;
+        }
+
+        @Test
+        public void getLastColumnTest() {
+            assertArrayEquals(lastColumn, matrix.getColumn(matrix.getColumnsCount() - 1));
+        }
+    }
+}

data/tracks/java/exercises/rectangles/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

data/tracks/java/exercises/rectangles/src/example/java/RectangleCounter.java

@@ -0,0 +1,115 @@
+import static java.util.Arrays.copyOfRange;
+import static java.util.Arrays.stream;
+
+final class RectangleCounter {
+
+    int countRectangles(final String[] rawGrid) {
+        final int nRows = rawGrid.length;
+        if (nRows == 0) return 0;
+
+        final int nCols = rawGrid[0].length();
+        if (nCols == 0) return 0;
+
+        return new Grid(nRows, nCols, rawGrid).countRectangles();
+    }
+
+    private static final class Grid {
+
+        private enum Entry {
+            CORNER,
+            HLINE,
+            VLINE,
+            SPACE;
+
+            private static Entry fromChar(final char rawGridEntry) {
+                switch (rawGridEntry) {
+                    case '+': return CORNER;
+                    case '-': return HLINE;
+                    case '|': return VLINE;
+                    case ' ': return SPACE;
+                    default:  throw new IllegalStateException("Grid entry " + rawGridEntry + " not recognized.");
+                }
+            }
+        }
+
+        private int nRows, nCols;
+        private final Entry[][] entries;
+
+        private Grid(final int nRows, final int nCols, final String[] rawGrid) {
+            this.nRows = nRows;
+            this.nCols = nCols;
+            this.entries = new Entry[nRows][nCols];
+
+            for (int nRow = 0; nRow < nRows; nRow++) {
+                for (int nCol = 0; nCol < nCols; nCol++) {
+                    entries[nRow][nCol] = Entry.fromChar(rawGrid[nRow].charAt(nCol));
+                }
+            }
+        }
+
+        private int countRectangles() {
+            int result = 0;
+
+            for (int topRow = 0; topRow < nRows - 1; topRow++) {
+
+                for (int leftCol = 0; leftCol < nCols - 1; leftCol++) {
+
+                    // Only check rectangles that lie below/to the right of our current coordinate:
+                    for (int bottomRow = topRow + 1; bottomRow < nRows; bottomRow++) {
+
+                        for (int rightCol = leftCol + 1; rightCol < nCols; rightCol++) {
+
+                            if (formsRectangle(topRow, bottomRow, leftCol, rightCol)) {
+                                result++;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        private boolean formsRectangle(
+                final int topRow,
+                final int bottomRow,
+                final int leftCol,
+                final int rightCol) {
+
+            return entries[topRow][leftCol].equals(Entry.CORNER)
+                    && entries[topRow][rightCol].equals(Entry.CORNER)
+                    && entries[bottomRow][leftCol].equals(Entry.CORNER)
+                    && entries[bottomRow][rightCol].equals(Entry.CORNER)
+                    && isHorizontalLineSegment(topRow, leftCol, rightCol)
+                    && isHorizontalLineSegment(bottomRow, leftCol, rightCol)
+                    && isVerticalLineSegment(leftCol, topRow, bottomRow)
+                    && isVerticalLineSegment(rightCol, topRow, bottomRow);
+        }
+
+        private boolean isHorizontalLineSegment(final int row, final int leftCol, final int rightCol) {
+            return stream(copyOfRange(getRow(row), leftCol, rightCol))
+                    .allMatch(entry -> entry.equals(Entry.HLINE) || entry.equals(Entry.CORNER));
+        }
+
+        private boolean isVerticalLineSegment(final int col, final int topRow, final int bottomRow) {
+            return stream(copyOfRange(getCol(col), topRow, bottomRow))
+                    .allMatch(entry -> entry.equals(Entry.VLINE) || entry.equals(Entry.CORNER));
+        }
+
+        private Entry[] getRow(final int number) {
+            return entries[number];
+        }
+
+        private Entry[] getCol(final int number) {
+            final Entry[] result = new Entry[nRows];
+
+            for (int nRow = 0; nRow < nRows; nRow++) {
+                result[nRow] = entries[nRow][number];
+            }
+
+            return result;
+        }
+
+    }
+
+}

data/tracks/java/exercises/rectangles/src/main/java/RectangleCounter.java

@@ -0,0 +1,5 @@
+final class RectangleCounter {
+
+
+
+}

data/tracks/java/exercises/rectangles/src/test/java/RectangleCounterTest.java

@@ -0,0 +1,164 @@
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public final class RectangleCounterTest {
+
+    private RectangleCounter rectangleCounter;
+
+    @Before
+    public void setUp() {
+        rectangleCounter = new RectangleCounter();
+    }
+
+    @Test
+    public void testInputWithNoColumnsContainsNoRectangles() {
+        String[] inputGrid = new String[]{};
+
+        assertEquals(0, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testNonTrivialInputWithNoRectangles() {
+        String[] inputGrid = new String[]{" "};
+
+        assertEquals(0, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testInputWithOneRectangle() {
+        String[] inputGrid = new String[]{
+                "+-+",
+                "| |",
+                "+-+"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testInputWithTwoRectanglesWithoutSharedEdges() {
+        String[] inputGrid = new String[]{
+                "  +-+",
+                "  | |",
+                "+-+-+",
+                "| |  ",
+                "+-+  "
+        };
+
+        assertEquals(2, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testInputWithFiveRectanglesWithSharedEdges() {
+        String[] inputGrid = new String[]{
+                "  +-+",
+                "  | |",
+                "+-+-+",
+                "| | |",
+                "+-+-+"
+        };
+
+        assertEquals(5, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatRectangleOfHeightOneIsCounted() {
+        String[] inputGrid = new String[]{
+                "+--+",
+                "+--+"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatRectangleOfWidthOneIsCounted() {
+        String[] inputGrid = new String[]{
+                "++",
+                "||",
+                "++"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatOneByOneSquareIsCounted() {
+        String[] inputGrid = new String[]{
+                "++",
+                "++"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatIncompleteRectanglesAreNotCounted() {
+        String[] inputGrid = new String[]{
+                "  +-+",
+                "    |",
+                "+-+-+",
+                "| | -",
+                "+-+-+"
+        };
+
+        assertEquals(1, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatRectanglesOfDifferentSizesAreAllCounted() {
+        String[] inputGrid = new String[]{
+                "+------+----+",
+                "|      |    |",
+                "+---+--+    |",
+                "|   |       |",
+                "+---+-------+"
+        };
+
+        assertEquals(3, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testThatIntersectionsWithoutCornerCharacterDoNotCountAsRectangleCorners() {
+        String[] inputGrid = new String[]{
+                "+------+----+",
+                "|      |    |",
+                "+------+    |",
+                "|   |       |",
+                "+---+-------+"
+        };
+
+        assertEquals(2, rectangleCounter.countRectangles(inputGrid));
+    }
+
+    @Ignore
+    @Test
+    public void testLargeInputWithManyRectangles() {
+        String[] inputGrid = new String[]{
+                "+---+--+----+",
+                "|   +--+----+",
+                "+---+--+    |",
+                "|   +--+----+",
+                "+---+--+--+-+",
+                "+---+--+--+-+",
+                "+------+  | |",
+                "          +-+"
+        };
+
+        assertEquals(60, rectangleCounter.countRectangles(inputGrid));
+    }
+
+}

data/tracks/java/exercises/settings.gradle

@@ -34,6 +34,7 @@ include 'phone-number'
 include 'pig-latin'
 include 'queen-attack'
 include 'raindrops'
+include 'rectangles'
 include 'rna-transcription'
 include 'robot-name'
 include 'robot-simulator'
@@ -54,4 +55,4 @@ include 'trinary'
 include 'word-count'
 include 'wordy'
 include 'twelve-days'
-
+include 'matrix'

data/tracks/julia/.travis.yml

@@ -1,5 +1,19 @@
-language: bash
+language: julia
+
+os:
+  - linux
+  - osx
+
+julia:
+  - release
+  - nightly
+  - 0.5
+
+matrix:
+  allow_failures:
+    - julia: nightly
 
 script:
-  - bin/fetch-configlet
-  - bin/configlet .
+  - julia runtests.jl
+  - ./bin/fetch-configlet
+  - ./bin/configlet .

data/tracks/julia/README.md

@@ -14,7 +14,7 @@ Please see the [contributing guide](https://github.com/exercism/x-common/blob/ma
 
 A pool of exercises can be found in the [x-Common repo](https://github.com/exercism/x-common).
 
-Exercises for the Julia track go in the `exercises` directory and should follow the following filename conventions: 
+Exercises for the Julia track go in the `exercises` directory and should follow the following filename conventions:
 
 `exercises/<slug>/<slug>.jl` Skeleton for the function that is called by the test suite. Provide (abstract) parameter and return types to ensure compatibility with the test suite.
 
@@ -25,3 +25,6 @@ Exercises for the Julia track go in the `exercises` directory and should follow
 Replace `<slug>` with the exercise slug of the exercise you're working on.
 
 See [Issue #2](https://github.com/exercism/xjulia/issues/2) for discussion on the structure.
+
+### Testing the example solutions
+Test your example solutions by running `julia runtests.jl` in the project directory. Specify exercise slugs as arguments to run only certain exercises: `julia runtests.jl <slug>`.

data/tracks/julia/docs/INSTALLATION.md

@@ -0,0 +1,5 @@
+To install Julia on your system follow the instructions on the [Julia Language Downloads page](http://julialang.org/downloads/).
+
+For a local installation, it is recommended to use [Juno](http://junolab.org/). It's an IDE based on Atom and offers a powerful text editor as well as additional features for developing in Julia. Just follow the instructions on their website.
+
+A simple way to get started with Julia without the need of a local installation is [JuliaBox](http://junolab.org/), which is an online IDE based on Jupyter notebooks. You just access it from your browser, login and you can start solving exercises.

data/tracks/julia/docs/LEARNING.md

@@ -0,0 +1,7 @@
+# Learning Julia From Scratch
+
+Exercism assumes that you already have some knowledge about the Julia language to the point where you understand the basic concept of a function and know the syntax reasonably well. The Julia language website contains a regularly updated [list of learning resources](http://julialang.org/learning/). This is the go-to place when looking for books and tutorials on Julia.
+
+For examples on what to do with Julia as well as more specific tutorials, check out [juliabloggers.com](http://www.juliabloggers.com/).
+
+Please note: Julia is a rather young and still rapidly evolving language and as such, examples from books or tutorials written for older versions of Julia may not work anymore without (small) adjustments.

data/tracks/julia/docs/TESTS.md

@@ -0,0 +1,5 @@
+# Running the tests
+Place yourself in the directory where the exercise has been fetched and run:
+```bash
+julia runtests.jl
+```

data/tracks/julia/runtests.jl

@@ -0,0 +1,32 @@
+using Base.Test
+
+for (root, dirs, files) in walkdir("exercises")
+    for exercise in dirs
+        # Allow only testing specified execises
+        if !isempty(ARGS) && !(exercise in ARGS)
+            continue
+        end
+
+        exercise_path = joinpath("exercises", exercise)
+
+        # Create temporary directory
+        temp_path = mktempdir(root)
+
+        # Copy tests & example to the temporary directory
+        cp(joinpath(exercise_path, "example.jl"), joinpath(temp_path, "$exercise.jl"))
+        cp(joinpath(exercise_path, "runtests.jl"), joinpath(temp_path, "runtests.jl"))
+
+        # Run the tests
+        result = @testset "$exercise example" begin
+            include(joinpath(temp_path, "runtests.jl"))
+        end
+
+        # Delete the temporary directory
+        rm(temp_path, recursive=true)
+
+        # Print test output (this is the default behaviour for older versions of Julia)
+        if VERSION > v"0.6.0-dev"
+            Base.Test.print_test_results(result)
+        end
+    end
+end

data/tracks/pascal/exercises/hello-world/uTestHelloWorld.pas

@@ -1,3 +1,30 @@
+//*****************************************************************************
+// You got an error, which is exactly as it should be.
+// This is the first step in the Test-Driven Development
+// (TDD) process.
+//
+// The most important part of the error is
+//
+//   "cannot compile"
+//
+// It's looking for a file named uHelloWorld.pas that doesn't exist.
+//
+// To fix the error, create a unit file named uHelloWorld.pas
+// in the same directory as the file uTestHelloWorld.pas.
+//
+// The beginning of the new unit file should contain a unit statement:
+//
+// unit uHelloWorld;
+//
+// The new unit should contain Interface, Implementation, and End. statements.
+//
+// Hint: Delphi will take care of all this if you instruct it to add a new unit
+// to your project.  Be sure to save the new unit as uHelloWorld.pas before
+// trying to compile again.
+//
+// For more guidance as you work on this exercise, see
+// GETTING_STARTED.md.
+//*****************************************************************************
 unit uTestHelloWorld;
 
 interface
@@ -39,26 +66,3 @@ end;
 initialization
   TDUnitX.RegisterTestFixture(HelloWorldTest);
 end.
-
-(*
-*****************************************************
-You got an error, which is exactly as it should be.
-This is the first step in the Test-Driven Development
-(TDD) process.
-
-The most important part of the error is
-
-   "cannot compile"
-
-It's looking for a file named uHelloWorld.pas that doesn't
-exist yet.
-
-To fix the error, create an empty file named uHelloWorld.pas
-in the same directory as the uTestHelloWorld.pas file.
-
-Then run the test again.
-
-For more guidance as you work on this exercise, see
-GETTING_STARTED.md.
-*****************************************************
-*)

data/tracks/python/README.md

@@ -1,6 +1,6 @@
 # xPython
 
-[![Build Status](https://travis-ci.org/exercism/xpython.png?branch=master)](https://travis-ci.org/exercism/xpython) [![Requirements Status](https://requires.io/github/exercism/xpython/requirements.svg?branch=master)](https://requires.io/github/exercism/xpython/requirements/?branch=master)
+[![Build Status](https://travis-ci.org/exercism/xpython.svg?branch=master)](https://travis-ci.org/exercism/xpython) [![Requirements Status](https://requires.io/github/exercism/xpython/requirements.svg?branch=master)](https://requires.io/github/exercism/xpython/requirements/?branch=master)
 [![Join the chat at https://gitter.im/exercism/xpython](https://badges.gitter.im/exercism/xpython.svg)](https://gitter.im/exercism/xpython?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 Exercism exercises in Python

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.6.13
+  version: 2.0.6.14
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-18 00:00:00.000000000 Z
+date: 2017-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -3669,6 +3669,10 @@ files:
 - tracks/java/exercises/luhn/src/example/java/Luhn.java
 - tracks/java/exercises/luhn/src/main/java/.keep
 - tracks/java/exercises/luhn/src/test/java/LuhnTest.java
+- tracks/java/exercises/matrix/build.gradle
+- tracks/java/exercises/matrix/src/example/java/Matrix.java
+- tracks/java/exercises/matrix/src/main/java/.keep
+- tracks/java/exercises/matrix/src/test/java/MatrixTest.java
 - tracks/java/exercises/meetup/build.gradle
 - tracks/java/exercises/meetup/src/example/java/Meetup.java
 - tracks/java/exercises/meetup/src/example/java/MeetupSchedule.java
@@ -3728,6 +3732,10 @@ files:
 - tracks/java/exercises/raindrops/src/example/java/Raindrops.java
 - tracks/java/exercises/raindrops/src/main/java/.keep
 - tracks/java/exercises/raindrops/src/test/java/RaindropsTest.java
+- tracks/java/exercises/rectangles/build.gradle
+- tracks/java/exercises/rectangles/src/example/java/RectangleCounter.java
+- tracks/java/exercises/rectangles/src/main/java/RectangleCounter.java
+- tracks/java/exercises/rectangles/src/test/java/RectangleCounterTest.java
 - tracks/java/exercises/rna-transcription/build.gradle
 - tracks/java/exercises/rna-transcription/src/example/java/RnaTranscription.java
 - tracks/java/exercises/rna-transcription/src/main/java/.keep
@@ -3999,6 +4007,7 @@ files:
 - tracks/julia/docs/TESTS.md
 - tracks/julia/exercises/.keep
 - tracks/julia/img/.keep
+- tracks/julia/runtests.jl
 - tracks/kotlin/.git
 - tracks/kotlin/.gitignore
 - tracks/kotlin/.travis.yml
@@ -5199,7 +5208,6 @@ files:
 - tracks/pascal/exercises/saddle-points/uSaddlePointsExample.pas
 - tracks/pascal/exercises/saddle-points/uSaddlePointsTests.pas
 - tracks/pascal/img/.keep
-- tracks/pascal/img/Delphi-icon.png.keep
 - tracks/pascal/img/icon.png
 - tracks/perl5/.git
 - tracks/perl5/.gitignore