trackler 2.2.1.134 → 2.2.1.135

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c199b6b186e79a6addc55c7b4c2ff2f43c3c39f6
-  data.tar.gz: c1c6657ba396dcb12f60736f1a09509e3c1eaf7c
+  metadata.gz: e668f282132d63c1231f79fddb5137f51faf314e
+  data.tar.gz: 127deef6f4aa01b28b4b74330f9826aed28fa24c
 SHA512:
-  metadata.gz: d8be6e7f925daa5c522612b69e7023de0c4d1708655dc85dd31b8bc48e954f3fcdf7220db6a0b4ecdf1d413f44f719e629aa23f3e4f39179cb65a383504140d3
-  data.tar.gz: 49926783363b14e9328ebfa736c8f72cedf49e9aefccd98e81d5f71ffb80f728032884189caa0afa6675f267402c8642b4c98ba27d29af492efa75665c0654a3
+  metadata.gz: 04c5e56a00719b737739a8490682bafee1888a1879a26a4a6b008ad301e5df2811d223bcf5f6cf819b834366863087b92dd77b78dd4ab524c7fe83e6dc31f3ca
+  data.tar.gz: d5dfc98f5a4349fa1c383b66f954eaeed399eb836f40fac6bde8a57531572c3b05513e2b59ab33e4b91761d5c5592f4f827d80532fdb684d9e84524e56151d15

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.134"
+  VERSION = "2.2.1.135"
 end

data/problem-specifications/exercises/series/canonical-data.json

@@ -0,0 +1,105 @@
+{
+  "exercise": "series",
+  "version": "1.0.0",
+  "cases": [
+    {
+      "description": "slices of one from one",
+      "property": "slices",
+      "input": {
+        "series": "1",
+        "sliceLength": 1
+      },
+      "expected": ["1"]
+    },
+    {
+      "description": "slices of one from two",
+      "property": "slices",
+      "input": {
+        "series": "12",
+        "sliceLength": 1
+      },
+      "expected": ["1", "2"]
+    },
+    {
+      "description": "slices of two",
+      "property": "slices",
+      "input": {
+        "series": "35",
+        "sliceLength": 2
+      },
+      "expected": ["35"]
+    },
+    {
+      "description": "slices of two overlap",
+      "property": "slices",
+      "input": {
+        "series": "9142",
+        "sliceLength": 2
+      },
+      "expected": ["91", "14", "42"]
+    },
+    {
+      "description": "slices can include duplicates",
+      "property": "slices",
+      "input": {
+        "series": "777777",
+        "sliceLength": 3
+      },
+      "expected": ["777", "777", "777", "777"]
+    },
+    {
+      "description": "slices of a long series",
+      "property": "slices",
+      "input": {
+        "series": "918493904243",
+        "sliceLength": 5
+      },
+      "expected": ["91849", "18493", "84939", "49390",
+                   "93904", "39042", "90424", "04243"]
+    },
+    {
+      "description": "slice length is too large",
+      "property": "slices",
+      "input": {
+        "series": "12345",
+        "sliceLength": 6
+      },
+      "expected": {
+        "error": "slice length cannot be greater than series length"
+      }
+    },
+    {
+      "description": "slice length cannot be zero",
+      "property": "slices",
+      "input": {
+        "series": "12345",
+        "sliceLength": 0
+      },
+      "expected": {
+        "error": "slice length cannot be zero"
+      }
+    },
+    {
+      "description": "slice length cannot be negative",
+      "property": "slices",
+      "input": {
+        "series": "123",
+        "sliceLength": -1
+      },
+      "expected": {
+        "error": "slice length cannot be negative"
+      }
+    },
+    {
+      "description": "empty series is invalid",
+      "property": "slices",
+      "input": {
+        "series": "",
+        "sliceLength": 1
+      },
+      "expected": {
+        "error": "series cannot be empty"
+      }
+    }
+  ]
+}

data/problem-specifications/exercises/series/description.md

@@ -1,16 +1,16 @@
 Given a string of digits, output all the contiguous substrings of length `n` in
-that string.
+that string in the order that they appear.
 
 For example, the string "49142" has the following 3-digit series:
 
-- 491
-- 914
-- 142
+- "491"
+- "914"
+- "142"
 
 And the following 4-digit series:
 
-- 4914
-- 9142
+- "4914"
+- "9142"
 
 And if you ask for a 6-digit series from a 5-digit string, you deserve
 whatever you get.

data/problem-specifications/exercises/sieve/description.md

@@ -3,8 +3,8 @@ number.
 
 The Sieve of Eratosthenes is a simple, ancient algorithm for finding all
 prime numbers up to any given limit. It does so by iteratively marking as
-composite (i.e. not prime) the multiples of each prime,
-starting with the multiples of 2.
+composite (i.e. not prime) the multiples of each prime, starting with the
+multiples of 2. It does not use any division or remainder operation.
 
 Create your range, starting at two and continuing up to and including the given limit. (i.e. [2, limit])
 
@@ -23,4 +23,6 @@ https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
 
 Notice that this is a very specific algorithm, and the tests don't check
 that you've implemented the algorithm, only that you've come up with the
-correct list of primes.
+correct list of primes. A good first test is to check that you do not use
+division or remainder operations (div, /, mod or % depending on the
+language).

data/tracks/ceylon/exercises/sieve/README.md

@@ -5,8 +5,8 @@ number.
 
 The Sieve of Eratosthenes is a simple, ancient algorithm for finding all
 prime numbers up to any given limit. It does so by iteratively marking as
-composite (i.e. not prime) the multiples of each prime,
-starting with the multiples of 2.
+composite (i.e. not prime) the multiples of each prime, starting with the
+multiples of 2. It does not use any division or remainder operation.
 
 Create your range, starting at two and continuing up to and including the given limit. (i.e. [2, limit])
 
@@ -25,7 +25,9 @@ https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
 
 Notice that this is a very specific algorithm, and the tests don't check
 that you've implemented the algorithm, only that you've come up with the
-correct list of primes.
+correct list of primes. A good first test is to check that you do not use
+division or remainder operations (div, /, mod or % depending on the
+language).
 
 ## Running Ceylon Tests
 

data/tracks/fsharp/.gitignore

@@ -11,3 +11,4 @@ paket-files
 .vs/
 .vscode/
 .dotnet
+*.fsproj.user

data/tracks/fsharp/docs/GENERATORS.md

@@ -0,0 +1,314 @@
+# Test Generators
+
+Test generators allow tracks to generate tests automatically without having to write them ourselves. Each test generator reads from the exercise's `canonical data`, which defines the name of the test, its inputs, and outputs. You can read more about exercism's approach to test suites [here](https://github.com/exercism/docs/blob/master/language-tracks/exercises/anatomy/test-suites.md).
+
+Generating tests automatically removes any sort of user error when creating tests. We want the tests to be accurate with respect to its canonical data. Test generation also makes it much easier to keep tests up to date. As the canonical data changes, the tests will be automatically updated when the generator for that test is run.
+
+An example of a canonical data file can be found [here](https://github.com/exercism/problem-specifications/blob/master/exercises/bob/canonical-data.json)
+
+## Common Terms
+
+When looking through the canonical data and the generator code base, we use a lot of common terminology. This list hopefully clarifies what they represent.
+
+* Canonical Data - Represents the entire test suite.
+* Canonical Data Case - A representation of a single test case.
+* Description - The name of the test.
+* Property - The method to be called when running the test.
+* Input - The input for the test case.
+* Expected - The expected value when running the test case.
+
+## Adding a simple generator
+
+Adding a test generator is straightforward. Simply add a class to the `Generators.fs` file in the `generators` folder with the name of the exercise (in PascalCase), and extend the `GeneratorExercise` abstract class.
+
+An example of a simple generator would be the Bob exercise. The source code can be found below, but you can also view it in the repository [here](https://github.com/exercism/fsharp/blob/master/generators/Generators.fs#L174).
+
+```fsharp
+type Bob() =
+    inherit GeneratorExercise()
+```
+
+This is a fully working generator, no other code needs to be written. However, it's simplicity stems from the fact that the test suite and the program itself are relatively trivial.
+
+## Adding a complex generator
+
+For many generators, the default behavior of the `GeneratorExercise` class suffices. However, for more _complex_ generators, one can override one or more of its virtual methods:
+
+### Method: RenderInput
+
+Render the input of a test method.
+
+#### Example
+
+The `Gigasecond` generator renders the input value as a (parenthesized) `DateTime` value:
+
+```fsharp
+override __.RenderInput (canonicalDataCase, key, value) =
+    DateTime.Parse(string value, CultureInfo.InvariantCulture)
+    |> formatDateTime
+    |> parenthesize
+```
+
+Note that you could use the `key` field to only customize the output for specific input fields. The `Yacht` generator does this:
+
+```fsharp
+override __.RenderInput (canonicalDataCase, key, value) =
+    match key with
+    | "category" -> sprintf "Category.%s" (string value |> String.dehumanize)
+    | _ -> base.RenderInput (canonicalDataCase, key, value)
+```
+
+### Method: RenderExpected
+
+Render the expected value of a test method.
+
+#### Example
+
+The `Connect` generator renders the expected value as an `Option<T>` value:
+
+```fsharp
+override __.RenderExpected (canonicalDataCase, key, value) =
+    match string value with
+    | "O" -> "(Some White)"
+    | "X" -> "(Some Black)"
+    | _   -> "None"
+```
+
+### Method: RenderSut
+
+Render the System Under Test (SUT). This is the actual value that is verified against the expected value.
+
+#### Example
+
+The `RunLengthEncoding` generator has a test case where it verifies that encoding and then decoding the input results in the same value. The `RenderSut` method is overridden to convert what would be a single call to a non-existing `consistency` function, to a chain of `encode |> decode` calls:
+
+```fsharp
+override this.RenderSut canonicalDataCase =
+    match canonicalDataCase.Property with
+    | "consistency" ->
+        let parameters = this.RenderSutParameters canonicalDataCase |> String.concat " "
+        sprintf "%s |> encode |> decode" parameters
+    | _ ->
+        base.RenderSut canonicalDataCase
+```
+
+### Method: RenderArrange
+
+Render the arrange part of the test method. In this part, the SUT is created.
+
+The default behavior is usually what you want. Only in very special circumstances would you want to change this.
+
+Note: this method returns a `string list`, where each `string` corresponds to a single, rendered line in the test file.
+
+### Method: RenderAssert
+
+Render the assert part of the test method. In this part, the assertion is made to verify the SUT against the expected value.
+
+The default behavior is usually what you want. Only in very special circumstances would you want to change this.
+
+Note: this method returns a `string list`, where each `string` corresponds to a single, rendered line in the test file.
+
+### Method: RenderSetup
+
+Render any additional utility/setup methods. This can be used to define helper methods that can be used in the test methods.
+
+The setup code is added _before_ the test methods, to enable the setup methods to be used in the test methods.
+
+Note: this method returns a `string list`, where each `string` corresponds to a single, rendered line in the test file.
+
+#### Example
+
+The `Zipper` generator adds two helper methods that are used in the test methods to remove some tedious, boilerplate code:
+
+```fsharp
+override __.RenderSetup _ =
+    [ "let subTree value left right = Some (tree value left right)"
+      "let leaf value = subTree value None None" ]
+    |> String.concat "\n"
+```
+
+### Method: RenderValue
+
+Render a single value (which is used to render input parameters, the expected value and the SUT).
+
+### Example
+
+The `ComplexNumbers` generator renders different values based on the value's type:
+
+```fsharp
+override __.RenderValue (canonicalDataCase, key, value) =
+    match value with
+    | :? JArray as jArray -> renderComplexNumber jArray
+    | :? int64 as i -> sprintf "%d.0" i
+    | _ -> base.RenderValue (canonicalDataCase, key, value)
+```
+
+### Method: MapCanonicalDataCase
+
+Map the canonical data case. This can be useful if you want to add or remove properties.
+
+The default behavior is usually what you want. Only in very special circumstances would you want to change this.
+
+#### Example
+
+The `ScaleGenerator` generator uses the canonical data case mapping to add a missing property as a `null` value (which makes processing later easier):
+
+```fsharp
+override __.MapCanonicalDataCase canonicalDataCase =
+    let input = canonicalDataCase.Input
+    match Map.tryFind "intervals" input with
+    | Some _ -> canonicalDataCase
+    | None   -> { canonicalDataCase with Input = Map.add "intervals" null input }
+```
+
+### Method: PropertiesUsedAsSutParameter
+
+Specifies which properties should be used as parameters to the SUT.
+
+The default behavior is usually what you want. Only in very special circumstances would you want to change this.
+
+#### Example
+
+The `RailFenceCipher` explicitly defines the properties used as SUT parameters to change the order in which they are passed:
+
+```fsharp
+override __.PropertiesUsedAsSutParameter _ = ["rails"; "msg"]
+```
+
+### Method: PropertiesWithIdentifier
+
+Specifies which properties should have an identifier assigned to them. If a property is in this list, it will be assigned its value on a separate line, to its own identifier.
+
+#### Example
+
+The `Transpose` generator has chosen to use identifiers for all properties:
+
+```fsharp
+override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
+```
+
+### Method: IdentifierTypeAnnotation
+
+In some cases, you want an identifier to have an explicit type. A common use case is when a value is an empty list. In those case, FsUnit needs a type annotation for it to successfully execute the assertion.
+
+#### Example
+
+The `Minesweeper` generator adds a `string list` type annotation for empty values:
+
+```fsharp
+override __.IdentifierTypeAnnotation (_, _, value) = 
+    match value :?> JArray |> Seq.isEmpty with 
+    | true  -> Some "string list"
+    | false -> None
+```
+
+### Method: AdditionalNamespaces
+
+Returns a list of additional namespaces to open in the test file.
+
+#### Example
+
+The `Gigasecond` generator works with `DateTime` instances, and thus adds its namespace to the additional namespaces list:
+
+```fsharp
+override __.AdditionalNamespaces = [typeof<DateTime>.Namespace]
+```
+
+### Method: AssertTemplate
+
+The assert template to use. You can find the full list of assert templates in `generators/Templates/_Assert*.liquid`
+
+#### Example
+
+The `RationalNumbers` generator uses the `"AssertEqualWithin"` template to allow for checking doubles for equality with a specific tolerance:
+
+```fsharp
+override __.AssertTemplate canonicalDataCase =
+    match canonicalDataCase.Expected with
+    | :? double -> "AssertEqualWithin"
+    | _ -> base.TestMethodBodyAssertTemplate(canonicalDataCase)
+```
+
+### Method: TestFileFormat
+
+The test file's format: either a module or a class.
+
+The default behavior is virtually always what you want. Only in extremely rare cases would you want to change this.
+
+#### Example
+
+The `Grep` generator defines itself as a test class to allow using setup and teardown methods:
+
+```fsharp
+override __.TestFileFormat = TestFileFormat.Class
+```
+
+### Method: TestMethodName
+
+Specifies the test method's name.
+
+The default behavior is usually what you want. Only in very special circumstances would you want to change this.
+
+#### Example
+
+The `Zipper` generator does some test method name cleanup:
+
+```fsharp
+override __.RenderTestMethodName canonicalDataCase =
+    let testMethodName = base.RenderTestMethodName canonicalDataCase
+    testMethodName.Replace("Set_", "Set ")
+```
+
+### Method: UseFullMethodName
+
+Indicates if the test method name that is used should use the full path, which means that for nested test cases, it will prepend the test method name with the parent(s) description(s).
+
+The default behavior is usually what you want. Only in cases where there would otherwise be multiple test methods with the same name would you want to change this.
+
+#### Method: Signature
+
+The `KindergartenGarden` generator uses full method names to prevent test method name clashes:
+
+```fsharp
+override __.UseFullMethodName _ = true
+```
+
+### Method: SkipTestMethod
+
+Indicates if the test method should be marked with the `Skip = true` property.
+
+The default behavior is virtually always what you want. Only in extremely rare cases would you want to change this.
+
+#### Method: Signature
+
+The `Markdown` exercises is a refactoring exercise, and as such all its tests should already be in a valid state. Therefore, it doesn't add the `Skip` property for any of its test methods:
+
+```fsharp
+override __.SkipTestMethod (_, _) = false
+```
+
+## Updating existing files
+
+It is possible that an existing exercise does not match the canonical data. It is OK to update the exercise stub and/or the exercise example to follow the canonical data!
+
+Also, if you find an issue with one of the existing generators or test suites simply open up the generator that you would like to update, make your changes, and then run the generators.
+
+## Running the generators
+
+This repository is coded against [.NET Core 2.x](https://www.microsoft.com/net/core). To run the generators all you need to do is run the following command in the generators directory:
+
+`dotnet run`
+
+This command will take all of the exercise generators that are defined, and generate all of the test cases for each exercise. We use reflection to get all of the exercises, so if you are adding a new test, the test will be automatically included when running the generator.
+
+If you only need to run a single generator, you can do so by running the following command:
+
+`dotnet run -e <exercise>`
+
+Once the generator has been run, you can view the output of your generation by navigating to the test file for that exercise. As an example, the test suite for the Bob exercise can be found at:
+
+`exercises/bob/BobTest.fs`
+
+## Submitting a generator
+
+If you are satisfied with the output of your generator, we would love for you to submit a pull request! Please include your generator, updated test suite, and any other corresponding files that you may have changed.