trackler 2.0.8.11 → 2.0.8.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7985975e695c967206c6399587638d7b92f6ddeb
-  data.tar.gz: f605cb15bcc556c8f153ebf0aa71768b773709c5
+  metadata.gz: 8b091050fe3cc2ae73ee5a8b167c29a75da6b27e
+  data.tar.gz: 49cb81538e56408fc123e98514ce483560c911a0
 SHA512:
-  metadata.gz: 3f6cd5026c972237c9495b8acd567fa1ac65fc949bcf2da45c797526fe5057cea00c78bd433f840c8003da55f729e675c184a65d4d6510aa589f31288b22350f
-  data.tar.gz: 8687e2946dec0948f8a7800850103074d894c24aba6d92a530ea452672788f7014abf9a3e5d03fcffb619a5e1cbd845f51784451eaad4444a0493c7240a40ba9
+  metadata.gz: b8e27dc574836d71a6cb2755b3d314c343670c4b5e72b7e27318790e1b01443804da89aa3cffe814f63c24bea448fcc67442b9c72378abb5aab7cda3872cd87d
+  data.tar.gz: beaf66dfdaf976e94aa2afa88d7851295a3f6a414cd46467a46cf73788f84700f00e402be3e29b8947da4e5813cefd79ee8edcba0c3ef46ed5faf771a630ce4f

data/common/README.md

@@ -36,21 +36,76 @@ There are three metadata files:
 ## Test Data Format (canonical-data.json)
 
 This data can be incorporated into test programs manually or extracted by a
-program.  The file contains a single JSON object with a key for documentation
-and keys for various tests that may be meaningful for a problem.
-
-The documentation uses the key "#" with a list of strings as the value.
-These strings document how the problem readme (`description.md`) is generally
-interpreted in test programs across different languages.  In addition to a
-mainstream implementation path, this information can also document significant
-variations.
-
-Each test case has the the following keys:
-- description: which will be used to name each generated test
-  - The description should not simply explain **what** each case is (that is redundant information)
-  - The description should explain **why** each case is there. For example, what kinds of implementation mistakes might this case help us find?
-- 'variable names': one or more variable names with values which will be passed to the solution method
-- expected: the expected result
+program.  The file format is described in `canonical-schema.json`, but it
+is easier to understand with a example:
+
+```json
+{ "exercise": "foobar"
+, "version" : "1.0.0"
+, "comments":
+    [ " Comments are always optional and can be used almost anywhere.      "
+    , "                                                                    "
+    , " They usually document how the exercise's readme ('description.md') "
+    , " is generally interpreted in test programs across different         "
+    , " languages.                                                         "
+    , "                                                                    "
+    , " In addition to a mainstream implementation path, this information  "
+    , " can also document significant variations.                          "
+    ]
+, "cases":
+    [ { "comments":
+          [ " A test case must have a 'description' and a 'property'.  "
+          , " Anything else is optional.                               "
+          , "                                                          "
+          , " The 'property' is a string in lowerCamelCase identifying "
+          , " the type of test, but most of the times it is just the   "
+          , " name of a function being tested.                         "
+          , "                                                          "
+          , " Test cases can have any number of additional keys, and   "
+          , " most of them also have an 'expected' one, defining the   "
+          , " value a test should return.                              "
+          ]
+      , "description": "Foo'ing a word returns it reversed"
+      , "property"   : "foo"
+      , "input"      : "lion"
+      , "expected"   : "noil"
+      }
+    , { "description": "Bar'ing a name returns its parts combined"
+      , "property"   : "bar"
+      , "firstName"  : "Alan"
+      , "lastName"   : "Smithee"
+      , "expected"   : "ASlmainthee"
+      }
+    , { "comments":
+          [ " Test cases can be arbitrarily grouped with a description "
+          , " to make organization easier.                             "
+          ]
+      , "description": "Abnormal inputs: numbers"
+      , "cases":
+          [ { "description": "Foo'ing a number returns nothing"
+            , "property"   : "foo"
+            , "input"      : "42"
+            , "expected"   : null
+            }
+          , { "description": "Bar'ing a name with numbers gives an error"
+            , "property"   : "bar"
+            , "firstName"  : "HAL"
+            , "lastName"   : "9000"
+            , "expected"   : { "error": "You should never bar a number" }
+            }
+          ]
+      }
+  ]
+}
+
+```
+
+Keep in mind that the description should not simply explain **what** each case
+is (that is redundant information) but also **why** each case is there. For
+example, what kinds of implementation mistakes might this case help us find?
+
+There are also some convention about `expected` that you must follow:
+
   - if the input is valid but there is no result for the input, the value at `"expected"` should be `null`.
   - if an error is expected (because the input is invalid, or any other reason), the value at `"expected"` should be an object containing exactly one property, `"error"`, whose value is a string.
     - The string should explain why the error would occur.

data/common/canonical-schema.json

@@ -0,0 +1,137 @@
+{
+   "comments":
+   [ " This is a JSON Schema for 'canonical-data.json' files.     "
+   , "                                                            "
+   , " It enforces just a general structure for all exercises,    "
+   , " without specifying how the test data should be organized   "
+   , " for each type of test. We do this to keep generality and   "
+   , " allow support for tests the do not fit well in the         "
+   , " 'function (input) == output' structure, like property      "
+   , " tests.                                                     "
+   , "                                                            "
+   , " The only thing enforced regarding how test data should be  "
+   , " structured is the error encoding, because it was agreed    "
+   , " and it doesn't restrict flexibility in a significant way.  "
+   , "                                                            "
+   , " Standardized property names may help when automatically    "
+   , " deriving JSON parsers in some languages, so we followed    "
+   , " a few conventions from the 'Google JSON Style Guide'.      "
+   , "                                                            "
+   , " Additionally, this schema strictly enforces letters, in    "
+   , " lowerCamelCase, for naming the 'property' being tested. We "
+   , " expect this regularity will allow an easier automatic      "
+   , " generation of function's names in test generators,         "
+   , " slightly reducing the amount of manually generated code.   "
+   ],
+
+   "$schema": "http://json-schema.org/draft-04/schema#",
+
+   "self": { "vendor" : "io.exercism"
+           , "name"   : "canonical-data"
+           , "format" : "jsonschema"
+           , "version": "1-0-0"
+           },
+
+   "$ref": "#/definitions/canonicalData",
+
+   "definitions":{
+
+      "canonicalData":
+          { "description": "This is the top-level file structure"
+          , "type"       : "object"
+          , "required"   : ["exercise" , "version", "cases"]
+          , "properties" :
+                { "exercise" : { "$ref": "#/definitions/exercise"  }
+                , "version"  : { "$ref": "#/definitions/version"   }
+                , "comments" : { "$ref": "#/definitions/comments"  }
+                , "cases"    : { "$ref": "#/definitions/testGroup" }
+                }
+          , "additionalProperties": false
+          },
+
+      "exercise":
+          { "description": "Exercise's slug (kebab-case)"
+          , "type"       : "string"
+          , "pattern"    : "^[a-z]+(-[a-z]+)*$"
+          },
+
+      "version" :
+          { "description" : "Semantic versioning: MAJOR.MINOR.PATCH"
+          , "type"        : "string"
+          , "pattern"     : "^(0|[1-9][0-9]*)(\\.(0|[1-9][0-9]*)){2}$"
+          },
+
+      "comments":
+          { "description": "An array of strings to fake multi-line comments"
+          , "type"       : "array"
+          , "items"      : { "type": "string" }
+          , "minItems"   : 1
+          },
+
+      "testGroup":
+          { "description": "An array of labeled test items"
+          , "type"       : "array"
+          , "items"      : { "$ref": "#/definitions/labeledTestItem" }
+          , "minItems"   : 1
+          },
+
+      "labeledTestItem":
+          { "description": "A single test or group of tests with a description"
+          , "oneOf": [ { "$ref": "#/definitions/labeledTest"      }
+                     , { "$ref": "#/definitions/labeledTestGroup" }
+                     ]
+          },
+
+      "labeledTest":
+          { "description": "A single test with a description"
+          , "type"       : "object"
+          , "required"   : ["description", "property"]
+          , "properties" :
+                { "description": { "$ref": "#/definitions/description" }
+                , "comments"   : { "$ref": "#/definitions/comments"    }
+                , "property"   : { "$ref": "#/definitions/property"    }
+                , "expected"   : { "$ref": "#/definitions/expected"    }
+                }
+          },
+
+      "labeledTestGroup":
+          { "description": "A group of tests with a description"
+          , "type"       : "object"
+          , "required"   : ["description", "cases"]
+          , "properties" :
+                { "description": { "$ref": "#/definitions/description" }
+                , "comments"   : { "$ref": "#/definitions/comments"    }
+                , "cases"      : { "$ref": "#/definitions/testGroup"   }
+                }
+          , "additionalProperties": false
+          },
+
+      "description":
+          { "description": "A short, clear, one-line description"
+          , "type"       : "string"
+          },
+
+      "property":
+          { "description": "A letters-only, lowerCamelCase property name"
+          , "type"       : "string"
+          , "pattern"    : "^[a-z]+([A-Z][a-z]+)*[A-Z]?$"
+          },
+
+      "expected":
+          { "description": "The expected return value of a test case"
+          , "properties":
+               { "error": { "$ref": "#/definitions/error" }
+               }
+          , "dependencies":
+               { "error": { "maxProperties": 1 }
+               }
+          },
+
+      "error":
+          { "description": "A message describing an error condition"
+          , "type"       : "string"
+          }
+
+    }
+
+}

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.11"
+  VERSION = "2.0.8.12"
 end

data/tracks/elixir/config.json

@@ -104,6 +104,13 @@
         "Enumerations"
       ]
     },
+    {
+      "slug": "simple-linked-list",
+      "difficulty": 1,
+      "topics": [
+        "Recursion"
+      ]
+    },
     {
       "slug": "anagram",
       "difficulty": 2,

data/tracks/elixir/exercises/simple-linked-list/example.exs

@@ -0,0 +1,86 @@
+defmodule LinkedList do
+  @opaque t :: tuple()
+
+  @doc """
+  Construct a new LinkedList
+  """
+  @spec new() :: t
+  def new() do
+    {}
+  end
+
+  @doc """
+  Push an item onto a LinkedList
+  """
+  @spec push(t, any()) :: t
+  def push(list, elem) do
+    {elem, list}
+  end
+
+  @doc """
+  Calculate the length of a LinkedList
+  """
+  @spec length(t) :: non_neg_integer()
+  def length(list) do
+    count_length(list, 0)
+  end
+
+  defp count_length({}, n), do: n
+  defp count_length({_, t}, n), do: count_length(t, n + 1)
+
+  @doc """
+  Determine if a LinkedList is empty
+  """
+  @spec empty?(t) :: boolean()
+  def empty?({}), do: true
+  def empty?(_), do: false
+
+  @doc """
+  Get the value of a head of the LinkedList
+  """
+  @spec peek(t) :: {:ok, any()} | {:error, :empty_list}
+  def peek({}), do: {:error, :empty_list}
+  def peek({x, _}), do: {:ok, x}
+
+  @doc """
+  Get tail of a LinkedList
+  """
+  @spec tail(t) :: {:ok, t} | {:error, :empty_list}
+  def tail({}), do: {:error, :empty_list}
+  def tail({_, t}), do: {:ok, t}
+
+  @doc """
+  Remove the head from a LinkedList
+  """
+  @spec pop(t) :: {:ok, any(), t} | {:error, :empty_list}
+  def pop({}), do: {:error, :empty_list}
+  def pop({h, t}), do: {:ok, h, t}
+
+  @doc """
+  Construct a LinkedList from a stdlib List
+  """
+  @spec from_list(list()) :: t
+  def from_list(list) do
+    List.foldr(list, new(), &push(&2, &1))
+  end
+
+  @doc """
+  Construct a stdlib List LinkedList from a LinkedList
+  """
+  @spec to_list(t) :: list()
+  def to_list(list) do
+    list |> do_to_list([]) |> Enum.reverse()
+  end
+  defp do_to_list({}, acc), do: acc
+  defp do_to_list({h, t}, acc), do: do_to_list(t, [h|acc])
+
+  @doc """
+  Reverse a LinkedList
+  """
+  @spec reverse(t) :: t
+  def reverse(list) do
+    do_reverse(list, new())
+  end
+  def do_reverse({}, acc), do: acc
+  def do_reverse({h, t}, acc), do: do_reverse(t, push(acc, h))
+end

data/tracks/elixir/exercises/simple-linked-list/linked_list.exs

@@ -0,0 +1,83 @@
+defmodule LinkedList do
+  @opaque t :: tuple()
+
+  @doc """
+  Construct a new LinkedList
+  """
+  @spec new() :: t
+  def new() do
+    # Your implementation here...
+  end
+
+  @doc """
+  Push an item onto a LinkedList
+  """
+  @spec push(t, any()) :: t
+  def push(list, elem) do
+    # Your implementation here...
+  end
+
+  @doc """
+  Calculate the length of a LinkedList
+  """
+  @spec length(t) :: non_neg_integer()
+  def length(list) do
+    # Your implementation here...
+  end
+
+  @doc """
+  Determine if a LinkedList is empty
+  """
+  @spec empty?(t) :: boolean()
+  def empty?(list) do
+    # Your implementation here...
+  end
+
+  @doc """
+  Get the value of a head of the LinkedList
+  """
+  @spec peek(t) :: {:ok, any()} | {:error, :empty_list}
+  def peek(list) do
+    # Your implementation here...
+  end
+
+  @doc """
+  Get tail of a LinkedList
+  """
+  @spec tail(t) :: {:ok, t} | {:error, :empty_list}
+  def tail(list) do
+    # Your implementation here...
+  end
+
+  @doc """
+  Remove the head from a LinkedList
+  """
+  @spec pop(t) :: {:ok, any(), t} | {:error, :empty_list}
+  def pop(list) do
+    # Your implementation here...
+  end
+
+  @doc """
+  Construct a LinkedList from a stdlib List
+  """
+  @spec from_list(list()) :: t
+  def from_list(list) do
+    # Your implementation here...
+  end
+
+  @doc """
+  Construct a stdlib List LinkedList from a LinkedList
+  """
+  @spec to_list(t) :: list()
+  def to_list(list) do
+    # Your implementation here...
+  end
+
+  @doc """
+  Reverse a LinkedList
+  """
+  @spec reverse(t) :: t
+  def reverse(list) do
+    # Your implementation here...
+  end
+end

data/tracks/elixir/exercises/simple-linked-list/linked_list_test.exs

@@ -0,0 +1,154 @@
+if !System.get_env("EXERCISM_TEST_EXAMPLES") do
+  Code.load_file("linked_list.exs", __DIR__)
+end
+
+ExUnit.start
+ExUnit.configure exclude: :pending, trace: true
+
+defmodule LinkedListTest do
+  use ExUnit.Case
+
+  test "length/1 of new list" do
+    list = LinkedList.new()
+    assert LinkedList.length(list) == 0
+  end
+
+  @tag :pending
+  test "empty?/1 of new list" do
+    list = LinkedList.new()
+    assert LinkedList.empty?(list)
+  end
+
+  @tag :pending
+  test "length/1 of list of 1 datum" do
+    list = LinkedList.new() |> LinkedList.push(10)
+    assert LinkedList.length(list) == 1
+  end
+
+  @tag :pending
+  test "empty?/1 of list of 1 datum" do
+    list = LinkedList.new() |> LinkedList.push(20)
+    refute LinkedList.empty?(list)
+  end
+
+  @tag :pending
+  test "peek/1 of list of 1 datum" do
+    list = LinkedList.new() |> LinkedList.push(20)
+    assert LinkedList.peek(list) == {:ok, 20}
+  end
+
+  @tag :pending
+  test "peek/1 of list of empty list" do
+    list = LinkedList.new()
+    assert LinkedList.peek(list) == {:error, :empty_list}
+  end
+
+  @tag :pending
+  test "tail/1 of empty list" do
+    list = LinkedList.new()
+    assert {:error, :empty_list} = LinkedList.tail(list)
+  end
+
+  @tag :pending
+  test "tail/1 of list of 1 datum" do
+    list = LinkedList.new() |> LinkedList.push(:hello)
+    assert {:ok, tail} = LinkedList.tail(list)
+    assert LinkedList.peek(tail) == {:error, :empty_list}
+  end
+
+  @tag :pending
+  test "pushed items are stacked" do
+    list =
+      LinkedList.new()
+      |> LinkedList.push(:a)
+      |> LinkedList.push(:b)
+    assert LinkedList.peek(list) == {:ok, :b}
+    assert {:ok, list} = LinkedList.tail(list)
+    assert LinkedList.peek(list) == {:ok, :a}
+    assert {:ok, list} = LinkedList.tail(list)
+    assert LinkedList.peek(list) == {:error, :empty_list}
+  end
+
+  @tag :pending
+  test "push 10 times" do
+    list = Enum.reduce(1..10, LinkedList.new(), &LinkedList.push(&2, &1))
+    assert LinkedList.peek(list) == {:ok, 10}
+    assert LinkedList.length(list) == 10
+  end
+
+  @tag :pending
+  test "pop/1 of list of 1 datum" do
+    list = LinkedList.new() |> LinkedList.push(:a)
+    assert {:ok, :a, tail} = LinkedList.pop(list)
+    assert LinkedList.length(tail) == 0
+  end
+
+  @tag :pending
+  test "popping frenzy" do
+    list = Enum.reduce(11..20, LinkedList.new(), &LinkedList.push(&2, &1))
+    assert LinkedList.length(list) == 10
+    assert {:ok, 20, list} = LinkedList.pop(list)
+    assert {:ok, 19, list} = LinkedList.pop(list)
+    assert {:ok, 18, list} = LinkedList.pop(list)
+    assert {:ok, 17, list} = LinkedList.pop(list)
+    assert {:ok, 16, list} = LinkedList.pop(list)
+    assert {:ok, 15} = LinkedList.peek(list)
+    assert LinkedList.length(list) == 5
+  end
+
+  @tag :pending
+  test "from_list/1 of empty list" do
+    list = LinkedList.from_list([])
+    assert LinkedList.length(list) == 0
+  end
+
+  @tag :pending
+  test "from_list/1 of 2 element list" do
+    list = LinkedList.from_list([:a, :b])
+    assert LinkedList.length(list) == 2
+    assert {:ok, :a, list} = LinkedList.pop(list)
+    assert {:ok, :b, list} = LinkedList.pop(list)
+    assert {:error, :empty_list} = LinkedList.pop(list)
+  end
+
+  @tag :pending
+  test "to_list/1 of empty list" do
+    list = LinkedList.new()
+    assert LinkedList.to_list(list) == []
+  end
+
+  @tag :pending
+  test "to_list/1 of list of 1 datum" do
+    list = LinkedList.from_list([:mon])
+    assert LinkedList.to_list(list) == [:mon]
+  end
+
+  @tag :pending
+  test "to_list/1 of list of 2 datum" do
+    list = LinkedList.from_list([:mon, :tues])
+    assert LinkedList.to_list(list) == [:mon, :tues]
+  end
+
+  @tag :pending
+  test "reverse/1 of list of 2 datum" do
+    list = LinkedList.from_list([1, 2, 3]) |> LinkedList.reverse()
+    assert LinkedList.to_list(list) == [3, 2, 1]
+  end
+
+  @tag :pending
+  test "reverse/1 of list of 200 datum" do
+    list = Enum.to_list(1..200)
+    linked_list = LinkedList.from_list(list) |> LinkedList.reverse()
+    assert LinkedList.to_list(linked_list) == Enum.reverse(list)
+  end
+
+  @tag :pending
+  test "reverse/1 round trip" do
+    list = Enum.to_list(1..200)
+    linked_list =
+      LinkedList.from_list(list)
+      |> LinkedList.reverse()
+      |> LinkedList.reverse()
+    assert LinkedList.to_list(linked_list) == list
+  end
+end