trackler 2.0.6.11 → 2.0.6.12

data/tracks/haskell/exercises/roman-numerals/src/Roman.hs

@@ -1,3 +1,3 @@
 module Roman (numerals) where
 
-numerals = undefined
+numerals = error "You need to implement this function."

data/tracks/haskell/exercises/run-length-encoding/src/RunLength.hs

@@ -1,7 +1,7 @@
 module RunLength (decode, encode) where
 
 decode :: String -> String
-decode = undefined
+decode = error "You need to implement this function."
 
 encode :: String -> String
-encode = undefined
+encode = error "You need to implement this function."

data/tracks/haskell/exercises/saddle-points/src/Matrix.hs

@@ -2,4 +2,4 @@ module Matrix (saddlePoints) where
 
 import Data.Array (Array)
 
-saddlePoints = undefined
+saddlePoints = error "You need to implement this function."

data/tracks/haskell/exercises/say/src/Say.hs

@@ -1,3 +1,3 @@
 module Say (inEnglish) where
 
-inEnglish = undefined
+inEnglish = error "You need to implement this function."

data/tracks/haskell/exercises/scrabble-score/src/Scrabble.hs

@@ -1,5 +1,5 @@
 module Scrabble (scoreLetter, scoreWord) where
 
-scoreLetter = undefined
+scoreLetter = error "You need to implement this function."
 
-scoreWord = undefined
+scoreWord = error "You need to implement this function."

data/tracks/haskell/exercises/secret-handshake/src/SecretHandshake.hs

@@ -1,3 +1,3 @@
 module SecretHandshake (handshake) where
 
-handshake = undefined
+handshake = error "You need to implement this function."

data/tracks/haskell/exercises/series/src/Series.hs

@@ -1,4 +1,4 @@
 module Series (slices) where
 
 slices :: Int -> String -> [[Int]]
-slices n xs = undefined
+slices n xs = error "You need to implement this function."

data/tracks/haskell/exercises/sgf-parsing/src/Sgf.hs

@@ -5,4 +5,4 @@ import Data.Text (Text)
 import Data.Tree (Tree)
 
 parseSgf :: Text -> Maybe (Tree (Map Text [Text]))
-parseSgf = undefined
+parseSgf = error "You need to implement this function."

data/tracks/haskell/exercises/sieve/src/Sieve.hs

@@ -1,3 +1,3 @@
 module Sieve (primesUpTo) where
 
-primesUpTo = undefined
+primesUpTo = error "You need to implement this function."

data/tracks/haskell/exercises/simple-cipher/src/Cipher.hs

@@ -1,10 +1,10 @@
 module Cipher (caesarDecode, caesarEncode, caesarEncodeRandom) where
 
 caesarDecode :: String -> String -> String
-caesarDecode = undefined
+caesarDecode = error "You need to implement this function."
 
 caesarEncode :: String -> String -> String
-caesarEncode = undefined
+caesarEncode = error "You need to implement this function."
 
 caesarEncodeRandom :: String -> IO (String, String)
-caesarEncodeRandom = undefined
+caesarEncodeRandom = error "You need to implement this function."

data/tracks/haskell/exercises/simple-linked-list/src/LinkedList.hs

@@ -13,25 +13,25 @@ module LinkedList
 data LinkedList a = Dummy
 
 datum :: LinkedList a -> a
-datum = undefined
+datum = error "You need to implement this function."
 
 fromList :: [a] -> LinkedList a
-fromList = undefined
+fromList = error "You need to implement this function."
 
 isNil :: LinkedList a -> Bool
-isNil = undefined
+isNil = error "You need to implement this function."
 
 new :: a -> LinkedList a -> LinkedList a
-new = undefined
+new = error "You need to implement this function."
 
 next :: LinkedList a -> LinkedList a
-next = undefined
+next = error "You need to implement this function."
 
 nil :: LinkedList a
-nil = undefined
+nil = error "You need to implement this function."
 
 reverseLinkedList :: LinkedList a -> LinkedList a
-reverseLinkedList = undefined
+reverseLinkedList = error "You need to implement this function."
 
 toList :: LinkedList a -> [a]
-toList = undefined
+toList = error "You need to implement this function."

data/tracks/haskell/exercises/space-age/src/SpaceAge.hs

@@ -10,4 +10,4 @@ data Planet = Mercury
             | Neptune
 
 ageOn :: Planet -> Float -> Float
-ageOn planet seconds = undefined
+ageOn planet seconds = error "You need to implement this function."

data/tracks/haskell/exercises/strain/src/Strain.hs

@@ -1,7 +1,7 @@
 module Strain (keep, discard) where
 
 discard :: (a -> Bool) -> [a] -> [a]
-discard = undefined
+discard = error "You need to implement this function."
 
 keep :: (a -> Bool) -> [a] -> [a]
-keep = undefined
+keep = error "You need to implement this function."

data/tracks/haskell/exercises/sublist/src/Sublist.hs

@@ -3,4 +3,4 @@ module Sublist (Sublist(..), sublist) where
 data Sublist = Equal | Sublist | Superlist | Unequal deriving (Eq, Show)
 
 sublist :: [a] -> [a] -> Sublist
-sublist = undefined
+sublist = error "You need to implement this function."

data/tracks/haskell/exercises/sum-of-multiples/src/SumOfMultiples.hs

@@ -1,3 +1,3 @@
 module SumOfMultiples (sumOfMultiples) where
 
-sumOfMultiples = undefined
+sumOfMultiples = error "You need to implement this function."

data/tracks/haskell/exercises/triangle/src/Triangle.hs

@@ -6,4 +6,4 @@ data TriangleType = Equilateral
                   | Illegal
                   deriving (Eq, Show)
 
-triangleType = undefined
+triangleType = error "You need to implement this function."

data/tracks/haskell/exercises/trinary/src/Trinary.hs

@@ -1,5 +1,5 @@
 module Trinary (readTri, showTri) where
 
-readTri = undefined
+readTri = error "You need to implement this function."
 
-showTri = undefined
+showTri = error "You need to implement this function."

data/tracks/haskell/exercises/word-count/src/WordCount.hs

@@ -1,4 +1,4 @@
 module WordCount (wordCount) where
 
 wordCount :: String -> [(String, Int)]
-wordCount xs = undefined
+wordCount xs = error "You need to implement this function."

data/tracks/haskell/exercises/wordy/src/WordProblem.hs

@@ -1,3 +1,3 @@
 module WordProblem (answer) where
 
-answer = undefined
+answer = error "You need to implement this function."

data/tracks/haskell/exercises/zebra-puzzle/src/ZebraPuzzle.hs

@@ -8,5 +8,5 @@ data Solution = Solution { waterDrinker :: Resident
                          } deriving (Eq, Show)
 
 solve :: Solution
-solve = undefined
+solve = error "You need to implement this function."
 

data/tracks/haskell/exercises/zipper/src/Zipper.hs

@@ -19,28 +19,28 @@ data BinTree a = BT { btValue :: a
 data Zipper a = Dummy deriving (Eq, Show)
 
 fromTree :: BinTree a -> Zipper a
-fromTree = undefined
+fromTree = error "You need to implement this function."
 
 toTree :: Zipper a -> BinTree a
-toTree = undefined
+toTree = error "You need to implement this function."
 
 value :: Zipper a -> a
-value = undefined
+value = error "You need to implement this function."
 
 left :: Zipper a -> Maybe (Zipper a)
-left = undefined
+left = error "You need to implement this function."
 
 right :: Zipper a -> Maybe (Zipper a)
-right = undefined
+right = error "You need to implement this function."
 
 up :: Zipper a -> Maybe (Zipper a)
-up = undefined
+up = error "You need to implement this function."
 
 setValue :: a -> Zipper a -> Zipper a
-setValue = undefined
+setValue = error "You need to implement this function."
 
 setLeft :: Maybe (BinTree a) -> Zipper a -> Zipper a
-setLeft = undefined
+setLeft = error "You need to implement this function."
 
 setRight :: Maybe (BinTree a) -> Zipper a -> Zipper a
-setRight = undefined
+setRight = error "You need to implement this function."

data/tracks/java/docs/MAINTAINING.md

@@ -0,0 +1,48 @@
+# Welcome!
+
+This is a guide/reference for maintainers of the Java track.
+
+- [Your New Permissions](#your-new-permissions)
+- [Maintainer Guides](#maintainer-guides)
+- [The Project Board](#the-project-board)
+- [Miscellaneous](#miscellaneous)
+
+## Your New Permissions 
+
+You now have write access to four repositories.  "write access" means you can: review, reject, accept and merge PRs; and push changes to these repos.  Despite having permissions to push, we tend to see review of even our own PRs.
+
+- [x-common](https://github.com/exercism/x-common) — the library of exercises.
+- [discussions](https://github.com/exercism/discussions) — the place where project-wide conversations happen. 
+  [issues sorted by most recently updated.](https://github.com/exercism/discussions/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)
+- [xjava](https://github.com/exercism/xjava) — yeah... you know what this one is. :)
+- [todo](https://github.com/exercism/todo) — not really used... might just go away completely in the future.
+
+## Maintainer Guides
+
+- **[exercism.io/docs/maintaining-a-track.md](https://github.com/exercism/exercism.io/blob/master/docs/maintaining-a-track.md)**
+- [exercism.io/docs/getting-involved-in-a-track.md](https://github.com/exercism/exercism.io/blob/master/docs/getting-involved-in-a-track.md)
+- [exercism.io/docs/reviewing-a-pull-request.md](https://github.com/exercism/exercism.io/blob/master/docs/reviewing-a-pull-request.md)
+
+## The Project Board
+
+GitHub issues are great, there's no way to easily set priorities.
+To do this, we're using a GitHub Project: https://github.com/exercism/xjava/projects/2.
+
+- **Epics** — issues that really represent bigger ideas.  These inspire creating a set of smaller issues to be elaborated...
+- **Icebox** — issues that just needs a little more detail to be "ready to play"...
+- **Backlog** — issues ready to be worked.  When we start working on an issue, we move it to the next column...
+- **Current** — issues in progress.  When we've considered it done, we move the card to...
+- **Delivered** — completed issues that could use another pair of eyes.  When these are reviewed they get moved to...
+- **Done** — issues we've complete.  Every so often, we get together and it's nice to review what we've completed. 
+  Once reviewed, we remove them from this Project.
+
+The point of this board is to make clear our shared priorities.  It's a tool you can use.
+However, if you have an idea and want to implement it, you can just do it; it does not have to be added to this board.
+
+## Miscellaneous
+
+- Issues marked with "policy" are current "team agreements": [exercism?label:policy](https://github.com/search?q=org%3Aexercism+label%3Apolicy).
+  This label is described in [discussions#96](https://github.com/exercism/discussions/issues/96).
+- Exercism has a Twitter account: [@Exercism.io](https://twitter.com/exercism_io); and a mailing list: https://tinyletter.com/exercism
+
+**Please feel free to ask any questions.  In our thinking, asking questions is far smarter than guessing.**

data/tracks/java/exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java

@@ -16,119 +16,119 @@ public final class QueenAttackCalculatorTest {
     public ExpectedException expectedException = ExpectedException.none();
 
     @Test
-    public void testCoordinateWithNegativeRankNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive rank.");
+    public void testQueensThatDoNotShareRankFileOrDiagonalCannotAttack() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
 
-        new BoardCoordinate(-2, 2);
+        assertFalse(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testCoordinateWithRankGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have rank <= 7.");
+    public void testQueensCanAttackOnTheSameRank() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
 
-        new BoardCoordinate(8, 4);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testCoordinateWithNegativeFileNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive file.");
+    public void testQueensCanAttackOnTheSameFile() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
 
-        new BoardCoordinate(2, -2);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testCoordinateWithFileGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have file <= 7.");
+    public void testQueensCanAttackOnFirstDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 4));
 
-        new BoardCoordinate(4, 8);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testNullCoordinateNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
+    public void testQueensCanAttackOnSecondDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
 
-        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testQueensMustNotOccupyTheSameSquare() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
+    public void testQueensCanAttackOnThirdDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(1, 1));
 
-        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testQueensThatDoNotShareRankFileOrDiagonalCannotAttack() {
+    public void testQueensCanAttackOnFourthDiagonal() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
 
-        assertFalse(calculator.canQueensAttackOneAnother());
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnTheSameRank() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
+    public void testCoordinateWithNegativeRankNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have positive rank.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new BoardCoordinate(-2, 2);
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnTheSameFile() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
+    public void testCoordinateWithRankGreaterThan7NotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have rank <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new BoardCoordinate(8, 4);
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnFirstDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 4));
+    public void testCoordinateWithNegativeFileNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have positive file.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new BoardCoordinate(2, -2);
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnSecondDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
+    public void testCoordinateWithFileGreaterThan7NotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have file <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new BoardCoordinate(4, 8);
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnThirdDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(1, 1));
+    public void testNullCoordinateNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
     }
 
     @Ignore
     @Test
-    public void testQueensCanAttackOnFourthDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
+    public void testQueensMustNotOccupyTheSameSquare() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
     }
 
 }

data/tracks/kotlin/exercises/etl/src/example/kotlin/ETL.kt

@@ -1,5 +1,5 @@
 object ETL {
-    fun transform(old: Map<Int, Collection<String>>): Map<String, Int> {
+    fun transform(old: Map<Int, Collection<Char>>): Map<Char, Int> {
         return old.flatMap { mapEntry -> mapEntry.value.map { word -> Pair(word.toLowerCase(), mapEntry.key) } }.toMap()
     }
 }

data/tracks/kotlin/exercises/etl/src/test/kotlin/ETLTest.kt

@@ -5,24 +5,24 @@ class ETLTest {
 
     @Test
     fun transformOneValue() {
-        val old = mapOf(1 to listOf("WORLD"))
-        val expected = mapOf("world" to 1)
+        val old = mapOf(1 to listOf('a'))
+        val expected = mapOf('a' to 1)
 
         assertEquals(expected, ETL.transform(old))
     }
 
     @Test
     fun transformMoreValues() {
-        val old = mapOf(1 to listOf("WORLD", "GSCHOOLERS"))
-        val expected = mapOf("world" to 1, "gschoolers" to 1)
+        val old = mapOf(1 to listOf('A', 'E', 'I'))
+        val expected = mapOf('a' to 1, 'e' to 1, 'i' to 1)
 
         assertEquals(expected, ETL.transform(old))
     }
 
     @Test
     fun moreKeys() {
-        val old = mapOf(1 to listOf("APPLE", "ARTICHOKE"), 2 to listOf("BOAT", "BALLERINA"))
-        val expected = mapOf("apple" to 1, "artichoke" to 1, "boat" to 2, "ballerina" to 2)
+        val old = mapOf(1 to listOf('A', 'E', 'I'), 2 to listOf('D', 'G'))
+        val expected = mapOf('a' to 1, 'e' to 1, 'i' to 1, 'd' to 2, 'g' to 2)
 
         assertEquals(expected, ETL.transform(old))
     }
@@ -30,21 +30,21 @@ class ETLTest {
     @Test
     fun fullDataset() {
         val old = mapOf(
-                1 to listOf("A", "E", "I", "O", "U", "L", "N", "R", "S", "T"),
-                2 to listOf("D", "G"),
-                3 to listOf("B", "C", "M", "P"),
-                4 to listOf("F", "H", "V", "W", "Y"),
-                5 to listOf("K"),
-                8 to listOf("J", "X"),
-                10 to listOf("Q", "Z")
+                1 to listOf('A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T'),
+                2 to listOf('D', 'G'),
+                3 to listOf('B', 'C', 'M', 'P'),
+                4 to listOf('F', 'H', 'V', 'W', 'Y'),
+                5 to listOf('K'),
+                8 to listOf('J', 'X'),
+                10 to listOf('Q', 'Z')
         )
         val expected = mapOf(
-                "a" to 1, "b" to 3, "c" to 3, "d" to 2, "e" to 1,
-                "f" to 4, "g" to 2, "h" to 4, "i" to 1, "j" to 8,
-                "k" to 5, "l" to 1, "m" to 3, "n" to 1, "o" to 1,
-                "p" to 3, "q" to 10, "r" to 1, "s" to 1, "t" to 1,
-                "u" to 1, "v" to 4, "w" to 4, "x" to 8, "y" to 4,
-                "z" to 10
+                'a' to 1, 'b' to 3, 'c' to 3, 'd' to 2, 'e' to 1,
+                'f' to 4, 'g' to 2, 'h' to 4, 'i' to 1, 'j' to 8,
+                'k' to 5, 'l' to 1, 'm' to 3, 'n' to 1, 'o' to 1,
+                'p' to 3, 'q' to 10, 'r' to 1, 's' to 1, 't' to 1,
+                'u' to 1, 'v' to 4, 'w' to 4, 'x' to 8, 'y' to 4,
+                'z' to 10
         )
 
         assertEquals(expected, ETL.transform(old))

data/tracks/kotlin/exercises/pangram/src/test/kotlin/PangramTest.kt

@@ -43,6 +43,11 @@ class PangramTest {
     fun mixedCaseAndPunctuation() {
         assertTrue(Pangrams.isPangram("\"Five quacking Zephyrs jolt my wax bed.\""))
     }
+    
+    @Test
+    fun mixedCaseDuplicatedCharacters() {
+        assertFalse(Pangrams.isPangram("the quick brown fox jumps over the lazy FOX"))
+    }
 
     @Test
     fun nonAsciiCharacters() {

data/tracks/lisp/docs/ABOUT.md

@@ -0,0 +1,9 @@
+Common Lisp is an offshoot of the long-running family of Lisp programming languages. 
+It's a multi-paradigm programming language that allows you to choose the approach and paradigm 
+according to your application domain.
+
+Common Lisp has fast prototyping capabilities, and exceptional support for object oriented programming. 
+It also boasts a macro system which allows you to adapt the language to your needs, 
+and a run-time environment which allows modification of running applications.
+
+To learn more about Common Lisp, take a look at [the Common Lisp homepage](https://common-lisp.net/).

data/tracks/lua/exercises/transpose/example.lua

@@ -1,7 +1,7 @@
 local function Grid(s)
   local width = 0
   local rows = {}
-  for row in s:gmatch('[^\n]+') do
+  for row in s:gmatch('([^\n]*)\n?') do
     table.insert(rows, row)
     width = math.max(width, #row)
   end

data/tracks/lua/exercises/transpose/transpose_spec.lua

@@ -17,6 +17,22 @@ describe('transpose', function()
     assert.are.equal('S\ni\nn\ng\nl\ne\n \nl\ni\nn\ne\n.', transpose('Single line.'))
   end)
 
+  it('should transpose a string with empty lines', function()
+    local input =
+      '\n' ..
+      'Line 2\n' ..
+      '\n' ..
+      'L4'
+    local expected =
+      ' L L\n' ..
+      ' i 4\n' ..
+      ' n\n' ..
+      ' e\n' ..
+      '  \n' ..
+      ' 2'
+    assert.are.equal(expected, transpose(input))
+  end)
+
   it('should transpose a string with the first line longer than the second', function()
     local input =
       'The fourth line.\n' ..