trackler 2.0.8.32 → 2.0.8.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cc6eaccb2054506665379c75e4e6eac1a1b18f8e
-  data.tar.gz: b4c0e4d2306d08b14bb309970c0ec5f608d520a5
+  metadata.gz: 378ca12e2afc9bb24632918400f6eda2a274edbe
+  data.tar.gz: 86c7fd6d6280d19c15a3e887f2bbd380442cec0d
 SHA512:
-  metadata.gz: 23a92f21a2611df2a1228a1f3383253469cc8d612e815cf858acd562b2550920094372b03a828ce41ba902d7025bf777b240ef166c95a30e7bcafaae6d818c22
-  data.tar.gz: 2b5276e0fc50034f1ac28587454c3839f44e1ae54ee97c60fb38d9e281f0222ae073b779f3b6fc521a90e2c4a83e8b3086e6cd4ef8ef03d35909446d67da20ae
+  metadata.gz: 9e407a254474cff7f8437b2e81e94e2e961cd744e14dd4c18636b73eba4a7b067a929e4cb258b8702f3a9ffaf0037fb710bb7da052acb2d78fe5c02a15a4a7f4
+  data.tar.gz: 837226938c97906142bb821b5917919562f475c7b0315c683a8e27b579cf7d4939fb341f188a39db94371fcb3e29adad6af0758525434f0f0017a9fd49a6230f

data/fixtures/tracks/animal/exercises/fish/included-via-symlink.txt

@@ -0,0 +1 @@
+This should get included in fish.

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.32"
+  VERSION = "2.0.8.33"
 end

data/tracks/elixir/config.json

@@ -35,6 +35,14 @@
         "string processing"
       ]
     },
+    {
+      "slug": "pig-latin",
+      "difficulty": 2,
+      "topics": [
+        "pattern matching",
+        "string processing"
+      ]
+    },
     {
       "slug": "space-age",
       "difficulty": 2,
@@ -318,6 +326,12 @@
       "topics": [
       ]
     },
+    {
+      "slug": "perfect-numbers",
+      "difficulty": 3,
+      "topics": [
+      ]
+    },
     {
       "slug": "diffie-hellman",
       "difficulty": 4,

data/tracks/elixir/exercises/change/change_test.exs

@@ -9,69 +9,69 @@ defmodule ChangeTest do
   use ExUnit.Case
 
   # @tag :pending
-  test "no coins make 0 change" do
-      coins = [1, 5, 10, 21, 25]
-      expected = []
-      assert Change.generate(coins, 0) == {:ok, expected}
+  test "single coin change" do
+    coins = [1, 5, 10, 25, 100]
+    expected = [25]
+    assert Change.generate(coins, 25) == {:ok, expected}
   end
 
   @tag :pending
-  test "cannot find negative change values" do
-      coins = [1, 2, 5]
-      assert Change.generate(coins, -5) == {:error, "cannot change"}
+  test "multiple coin change" do
+    coins = [1, 5, 10, 25, 100]
+    expected = [5, 10]
+    assert Change.generate(coins, 15) == {:ok, expected}
   end
 
   @tag :pending
-  test "error testing for change smaller than the smallest of coins" do
-      coins = [5, 10]
-      assert Change.generate(coins, 3) == {:error, "cannot change"}
+  test "change with Lilliputian Coins" do
+    coins = [1, 4, 15, 20, 50]
+    expected = [4, 4, 15]
+    assert Change.generate(coins, 23) == {:ok, expected}
   end
 
   @tag :pending
-  test "single coin change" do
-      coins = [1, 5, 10, 25, 100]
-      expected = [25]
-      assert Change.generate(coins, 25) == {:ok, expected}
+  test "change with Lower Elbonia Coins" do
+    coins = [1, 5, 10, 21, 25]
+    expected = [21, 21, 21]
+    assert Change.generate(coins, 63) == {:ok, expected}
   end
 
   @tag :pending
-  test "multiple coin change" do
-      coins = [1, 5, 10, 25, 100]
-      expected = [5, 10]
-      assert Change.generate(coins, 15) == {:ok, expected}
+  test "large target values" do
+    coins = [1, 2, 5, 10, 20, 50, 100]
+    expected = [2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100]
+    assert Change.generate(coins, 999) == {:ok, expected}
   end
 
-   @tag :pending
-   test "possible change without unit coins available" do
-      coins = [2, 5, 10, 20, 50]
-      expected = [2, 2, 2, 5, 10]
-      assert Change.generate(coins, 21) == {:ok, expected}
-   end
-
   @tag :pending
-  test "change with Lilliputian Coins" do
-      coins = [1, 4, 15, 20, 50]
-      expected = [4, 4, 15]
-      assert Change.generate(coins, 23) == {:ok, expected}
+  test "possible change without unit coins available" do
+    coins = [2, 5, 10, 20, 50]
+    expected = [2, 2, 2, 5, 10]
+    assert Change.generate(coins, 21) == {:ok, expected}
   end
 
   @tag :pending
-  test "change with Lower Elbonia Coins" do
-      coins = [1, 5, 10, 21, 25]
-      expected = [21, 21, 21]
-      assert Change.generate(coins, 63) == {:ok, expected}
+  test "no coins make 0 change" do
+    coins = [1, 5, 10, 21, 25]
+    expected = []
+    assert Change.generate(coins, 0) == {:ok, expected}
   end
 
   @tag :pending
-  test "large target values" do
-      coins = [1, 2, 5, 10, 20, 50, 100]
-      expected = [2, 2, 5, 20, 20, 50, 100, 100, 100, 100, 100, 100, 100, 100, 100]
-      assert Change.generate(coins, 999) == {:ok, expected}
+  test "error testing for change smaller than the smallest of coins" do
+    coins = [5, 10]
+    assert Change.generate(coins, 3) == {:error, "cannot change"}
   end
 
   @tag :pending
   test "error if no combination can add up to target" do
-      coins = [5, 10]
-      assert Change.generate(coins, 94) == {:error, "cannot change"}
+    coins = [5, 10]
+    assert Change.generate(coins, 94) == {:error, "cannot change"}
+  end
+
+  @tag :pending
+  test "cannot find negative change values" do
+    coins = [1, 2, 5]
+    assert Change.generate(coins, -5) == {:error, "cannot change"}
   end
 end

data/tracks/elixir/exercises/perfect-numbers/example.exs

@@ -0,0 +1,34 @@
+defmodule PerfectNumbers do
+  @doc """
+  Determine the aliquot sum of the given `number`, by summing all the factors
+  of `number`, aside from `number` itself.
+
+  Based on this sum, classify the number as:
+
+  :perfect if the aliquot sum is equal to `number`
+  :abundant if the aliquot sum is greater than `number`
+  :deficient if the aliquot sum is less than `number`
+  """
+  @spec classify(number :: integer) :: ({ :ok, atom } | { :error, String.t() })
+  def classify(number) when number < 1, do: { :error, "Classification is only possible for natural numbers." }
+  def classify(number) do
+    { :ok, number |> aliquot_sum |> do_classify(number) }
+  end
+
+  defp do_classify(aliquot, aliquot), do: :perfect
+  defp do_classify(aliquot, number) when aliquot > number, do: :abundant
+  defp do_classify(_, _), do: :deficient
+
+  defp aliquot_sum(number) do
+    number
+    |> factors
+    |> Enum.reject(&(&1 == number))
+    |> Enum.sum
+  end
+
+  defp factors(number), do: factors(number, div(number, 2))
+  defp factors(1, _), do: [1]
+  defp factors(_, 1), do: [1]
+  defp factors(number, i) when rem(number, i) == 0, do: [i | factors(number, i-1)]
+  defp factors(number, i), do: factors(number, i-1)
+end

data/tracks/elixir/exercises/perfect-numbers/perfect_numbers.exs

@@ -0,0 +1,16 @@
+defmodule PerfectNumbers do
+  @doc """
+  Determine the aliquot sum of the given `number`, by summing all the factors
+  of `number`, aside from `number` itself.
+
+  Based on this sum, classify the number as:
+
+  :perfect if the aliquot sum is equal to `number`
+  :abundant if the aliquot sum is greater than `number`
+  :deficient if the aliquot sum is less than `number`
+  """
+  @spec classify(number :: integer) :: ({ :ok, atom } | { :error, String.t() })
+  def classify(number) do
+  end
+end
+

data/tracks/elixir/exercises/perfect-numbers/perfect_numbers_test.exs

@@ -0,0 +1,84 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("perfect_numbers.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule PerfectNumbersTest do
+  use ExUnit.Case
+
+  describe "Perfect numbers" do
+    #@tag :pending
+    test "Smallest perfect number is classified correctly" do
+      assert PerfectNumbers.classify(6) == { :ok, :perfect }
+    end
+
+    @tag :pending
+    test "Medium perfect number is classified correctly" do
+      assert PerfectNumbers.classify(28) == { :ok, :perfect }
+    end
+
+    @tag :pending
+    test "Large perfect number is classified correctly" do
+      assert PerfectNumbers.classify(33550336) == { :ok, :perfect }
+    end
+  end
+
+  describe "Abundant numbers" do
+    @tag :pending
+    test "Smallest abundant number is classified correctly" do
+      assert PerfectNumbers.classify(12) == { :ok, :abundant }
+    end
+
+    @tag :pending
+    test "Medium abundant number is classified correctly" do
+      assert PerfectNumbers.classify(30) == { :ok, :abundant }
+    end
+
+    @tag :pending
+    test "Large abundant number is classified correctly" do
+      assert PerfectNumbers.classify(33550335) == { :ok, :abundant }
+    end
+  end
+
+  describe "Deficient numbers" do
+    @tag :pending
+    test "Smallest prime deficient number is classified correctly" do
+      assert PerfectNumbers.classify(2) == { :ok, :deficient }
+    end
+
+    @tag :pending
+    test "Smallest non-prime deficient number is classified correctly" do
+      assert PerfectNumbers.classify(4) == { :ok, :deficient }
+    end
+
+    @tag :pending
+    test "Medium deficient number is classified correctly" do
+      assert PerfectNumbers.classify(32) == { :ok, :deficient }
+    end
+
+    @tag :pending
+    test "Large deficient number is classified correctly" do
+      assert PerfectNumbers.classify(33550337) == { :ok, :deficient }
+    end
+
+    @tag :pending
+    test "Edge case (no factors other than itself) is classified correctly" do
+      assert PerfectNumbers.classify(1) == { :ok, :deficient }
+    end
+  end
+
+  describe "Invalid inputs" do
+    @tag :pending
+    test "Zero is rejected (not a natural number)" do
+      assert PerfectNumbers.classify(0) == { :error, "Classification is only possible for natural numbers." }
+    end
+
+    @tag :pending
+    test "Negative integer is rejected (not a natural number)" do
+      assert PerfectNumbers.classify(-1) == { :error, "Classification is only possible for natural numbers." }
+    end
+  end
+end
+

data/tracks/elixir/exercises/pig-latin/example.exs

@@ -0,0 +1,44 @@
+defmodule PigLatin do
+  @doc """
+  Given a `phrase`, translate it a word at a time to Pig Latin.
+
+  Words beginning with consonants should have the consonant moved to the end of
+  the word, followed by "ay".
+
+  Words beginning with vowels (aeiou) should have "ay" added to the end of the
+  word.
+
+  Some groups of letters are treated like consonants, including "ch", "qu",
+  "squ", "th", "thr", and "sch".
+
+  Some groups are treated like vowels, including "yt" and "xr".
+  """
+  @spec translate(phrase :: String.t()) :: String.t()
+  def translate(phrase) do
+    phrase
+    |> String.split(" ")
+    |> Enum.map_join(" ", &to_pig_latin/1)
+  end
+
+  @consonant_sounds ["ch", "sch", "qu", "squ", "thr", "th"]
+  @vowel_sounds ["xr", "yt"]
+  @consonants "bcdfghjklmnpqrstvwxyz" |> String.graphemes
+  @vowels "aeiou" |> String.graphemes
+
+  for sound <- @consonant_sounds do
+    defp to_pig_latin(unquote(sound) <> rest), do: "#{rest}#{unquote(sound)}ay"
+  end
+
+  for sound <- @vowel_sounds do
+    defp to_pig_latin(unquote(sound) <> rest), do: "#{unquote(sound)}#{rest}ay"
+  end
+
+  for sound <- @consonants do
+    defp to_pig_latin(unquote(sound) <> rest), do: "#{rest}#{unquote(sound)}ay"
+  end
+
+  for sound <- @vowels do
+    defp to_pig_latin(unquote(sound) <> rest), do: "#{unquote(sound)}#{rest}ay"
+  end
+end
+

data/tracks/elixir/exercises/pig-latin/pig_latin.exs

@@ -0,0 +1,20 @@
+defmodule PigLatin do
+  @doc """
+  Given a `phrase`, translate it a word at a time to Pig Latin.
+
+  Words beginning with consonants should have the consonant moved to the end of
+  the word, followed by "ay".
+
+  Words beginning with vowels (aeiou) should have "ay" added to the end of the
+  word.
+
+  Some groups of letters are treated like consonants, including "ch", "qu",
+  "squ", "th", "thr", and "sch".
+
+  Some groups are treated like vowels, including "yt" and "xr".
+  """
+  @spec translate(phrase :: String.t()) :: String.t()
+  def translate(phrase) do
+  end
+end
+

data/tracks/elixir/exercises/pig-latin/pig_latin_test.exs

@@ -0,0 +1,121 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("pig_latin.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule PigLatinTest do
+  use ExUnit.Case
+
+  describe "ay is added to words that start with vowels" do
+    #@tag :pending
+    test "word beginning with a" do
+      assert PigLatin.translate("apple") == "appleay"
+    end
+
+    @tag :pending
+    test "word beginning with e" do
+      assert PigLatin.translate("ear") == "earay"
+    end
+
+    @tag :pending
+    test "word beginning with i" do
+      assert PigLatin.translate("igloo") == "iglooay"
+    end
+
+    @tag :pending
+    test "word beginning with o" do
+      assert PigLatin.translate("object") == "objectay"
+    end
+
+    @tag :pending
+    test "word beginning with u" do
+      assert PigLatin.translate("under") == "underay"
+    end
+
+    @tag :pending
+    test "word beginning with a vowel and followed by a qu" do
+      assert PigLatin.translate("equal") == "equalay"
+    end
+  end
+
+  describe "first letter and ay are moved to the end of words that start with consonants" do
+    @tag :pending
+    test "word beginning with p" do
+      assert PigLatin.translate("pig") == "igpay"
+    end
+
+    @tag :pending
+    test "word beginning with k" do
+      assert PigLatin.translate("koala") == "oalakay"
+    end
+
+    @tag :pending
+    test "word beginning with y" do
+      assert PigLatin.translate("yellow") == "ellowyay"
+    end
+
+    @tag :pending
+    test "word beginning with x" do
+      assert PigLatin.translate("xenon") == "enonxay"
+    end
+
+    @tag :pending
+    test "word beginning with q without a following u" do
+      assert PigLatin.translate("qat") == "atqay"
+    end
+  end
+
+  describe "some letter clusters are treated like a single consonant" do
+    @tag :pending
+    test "word beginning with ch" do
+      assert PigLatin.translate("chair") == "airchay"
+    end
+
+    @tag :pending
+    test "word beginning with qu" do
+      assert PigLatin.translate("queen") == "eenquay"
+    end
+
+    @tag :pending
+    test "word beginning with qu and a preceding consonant" do
+      assert PigLatin.translate("square") == "aresquay"
+    end
+
+    @tag :pending
+    test "word beginning with th" do
+      assert PigLatin.translate("therapy") == "erapythay"
+    end
+
+    @tag :pending
+    test "word beginning with thr" do
+      assert PigLatin.translate("thrush") == "ushthray"
+    end
+
+    @tag :pending
+    test "word beginning with sch" do
+      assert PigLatin.translate("school") == "oolschay"
+    end
+  end
+
+  describe "some letter clusters are treated like a single vowel" do
+    @tag :pending
+    test "word beginning with yt" do
+      assert PigLatin.translate("yttria") == "yttriaay"
+    end
+
+    @tag :pending
+    test "word beginning with xr" do
+      assert PigLatin.translate("xray") == "xrayay"
+    end
+  end
+
+  describe "phrases are translated" do
+    @tag :pending
+    test "a whole phrase" do
+      assert PigLatin.translate("quick fast run") == "ickquay astfay unray"
+    end
+  end
+end
+

data/tracks/erlang/README.md

@@ -4,7 +4,7 @@
 
 Exercism exercises in Erlang
 
-## Contributing Guide
+## Contributing guide
 
 For general information about how exercism works, please see the
 [contributing guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data).

data/tracks/erlang/SETUP.md

@@ -1,16 +1,34 @@
-* * * *
+## Running tests
 
-For installation and learning resources, refer to the
-[exercism help page](http://exercism.io/languages/erlang).
+In order to run the tests, issue the following command from the exercise
+directory:
 
-For running the tests provided, only libraries delivered with recent
-versions of erlang are used, so there is no need to install anything.
+```bash
+$ rebar3 eunit
+```
+
+### Test versioning
+
+Each problem defines a macro `TEST_VERSION` in the test file and
+verifies that the solution defines and exports a function `test_version`
+returning that same value.
+
+To make this test pass, add the following to your solution:
 
-In order to run the tests, you can issue the following commands from
-the exercise directory. Please substitute `$EXERCISE` with the
-exercises name.
+```erlang
+-export([test_version/0]).
 
-```sh
-erl -make
-erl -noshell -eval "eunit:test($EXERCISE, [verbose])" -s init stop
+test_version() ->
+  1.
 ```
+
+The benefit of this is that reviewers can see against which test version
+an iteration was written if, for example, a previously posted solution
+does not pass current tests.
+
+## Questions?
+
+For detailed information about the Erlang track, please refer to the
+[help page](http://exercism.io/languages/erlang) on the Exercism site.
+This covers the basic information on setting up the development
+environment expected by the exercises.

data/tracks/erlang/docs/INSTALLATION.md

@@ -9,16 +9,12 @@ Update your Homebrew to latest:
 $ brew update
 ```
 
-Install Erlang:
+Install Erlang and Rebar3:
 
 ```bash
-$ brew install erlang
+$ brew install erlang rebar@3
 ```
 
-Also fetch the latest `rebar3` from rebar3.org and put it somewhere in
-your `$PATH` and make it executable. (PRs that describe this better or
-via `brew` are welcome).
-
 ### On Linux
 
 * Fedora 17+ and Fedora Rawhide: `sudo yum -y install erlang`

data/tracks/haskell/exercises/pov/.dummylink

@@ -0,0 +1 @@
+resolver: lts-8.2

data/tracks/java/exercises/sieve/src/test/java/SieveTest.java

@@ -2,6 +2,7 @@ import org.junit.Test;
 import org.junit.Ignore;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import static org.junit.Assert.assertEquals;
@@ -12,7 +13,7 @@ public class SieveTest {
     @Test
     public void findFirstPrime() {
         Sieve sieve = new Sieve(2);
-        List<Integer> expectedOutput = Arrays.asList(new Integer[]{2});
+        List<Integer> expectedOutput = Collections.singletonList(2);
 
         assertEquals(expectedOutput, sieve.getPrimes());
     }

data/tracks/kotlin/exercises/allergies/src/example/kotlin/Allergen.kt

@@ -0,0 +1,10 @@
+enum class Allergen(val score: Int) {
+    EGGS(1),
+    PEANUTS(2),
+    SHELLFISH(4),
+    STRAWBERRIES(8),
+    TOMATOES(16),
+    CHOCOLATE(32),
+    POLLEN(64),
+    CATS(128)
+}

data/tracks/python/docs/INSTALLATION.md

@@ -1,10 +1,5 @@
-If Python isn't already available on your system follow the instructions at [the Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/#getting-started) to install Python on your computer.
+## Installing Python
 
-Exercism currently supports Python3.4, Python3.3 and Python2.7.
+If Python isn't already available on your system follow the instructions at [the Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/starting/installation/) to install Python on your computer.
 
-
-## Packages
-
-The [Python Package Index](https://pypi.python.org/pypi) contains thousands of packages.
-Pretty much each of them is installable with `pip install packagename`.
-If you don't have __pip__ already, [get it now](https://pip.pypa.io/en/latest/installing.html)!
+Exercism currently supports Python2.7 and Python 3.3+.

data/tracks/python/exercises/gigasecond/gigasecond_test.py

@@ -1,31 +1,34 @@
-from datetime import datetime
 import unittest
 
+from datetime import datetime
+
 from gigasecond import add_gigasecond
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+
 class GigasecondTest(unittest.TestCase):
-    def test_1(self):
+    def test_date_only_specification_of_time(self):
         self.assertEqual(
             add_gigasecond(datetime(2011, 4, 25)),
             datetime(2043, 1, 1, 1, 46, 40))
 
-    def test_2(self):
+    def test_another_date_only_specification_of_time(self):
         self.assertEqual(
             add_gigasecond(datetime(1977, 6, 13)),
             datetime(2009, 2, 19, 1, 46, 40))
 
-    def test_3(self):
+    def test_one_more_date_only_specification_of_time(self):
         self.assertEqual(
             add_gigasecond(datetime(1959, 7, 19)),
             datetime(1991, 3, 27, 1, 46, 40))
 
-    def test_4(self):
+    def test_full_time_specified(self):
         self.assertEqual(
             add_gigasecond(datetime(2015, 1, 24, 22, 0, 0)),
             datetime(2046, 10, 2, 23, 46, 40))
 
-    def test_5(self):
+    def test_full_time_with_day_roll_over(self):
         self.assertEqual(
             add_gigasecond(datetime(2015, 1, 24, 23, 59, 59)),
             datetime(2046, 10, 3, 1, 46, 39))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.0.8.32
+  version: 2.0.8.33
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-26 00:00:00.000000000 Z
+date: 2017-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -2535,9 +2535,15 @@ files:
 - tracks/elixir/exercises/pascals-triangle/example.exs
 - tracks/elixir/exercises/pascals-triangle/pascals_triangle.exs
 - tracks/elixir/exercises/pascals-triangle/pascals_triangle_test.exs
+- tracks/elixir/exercises/perfect-numbers/example.exs
+- tracks/elixir/exercises/perfect-numbers/perfect_numbers.exs
+- tracks/elixir/exercises/perfect-numbers/perfect_numbers_test.exs
 - tracks/elixir/exercises/phone-number/example.exs
 - tracks/elixir/exercises/phone-number/phone_number.exs
 - tracks/elixir/exercises/phone-number/phone_number_test.exs
+- tracks/elixir/exercises/pig-latin/example.exs
+- tracks/elixir/exercises/pig-latin/pig_latin.exs
+- tracks/elixir/exercises/pig-latin/pig_latin_test.exs
 - tracks/elixir/exercises/poker/example.exs
 - tracks/elixir/exercises/poker/poker.exs
 - tracks/elixir/exercises/poker/poker_test.exs
@@ -8703,7 +8709,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.6
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: The Exercism exercises data

data/fixtures/tracks/animal/exercises/fish/included-via-symlink.txt

@@ -1 +0,0 @@
-fixtures/tracks/animal/exercises/fish/../../.meta/include-in-fish.txt

data/tracks/haskell/exercises/pov/.dummylink

@@ -1 +0,0 @@
-tracks/haskell/exercises/pov/../../common/stack.yaml

data/tracks/kotlin/exercises/allergies/src/example/kotlin/Allergen.kt

@@ -1 +0,0 @@
-tracks/kotlin/exercises/allergies/src/example/kotlin/../../main/kotlin/Allergen.kt