trackler 2.2.1.88 → 2.2.1.89

data/tracks/fsharp/generators/Generators.fs

@@ -3,6 +3,7 @@ module Generators.Generators
 open System
 open System.Globalization
 open Newtonsoft.Json.Linq
+open CanonicalData
 open Formatting
 open Rendering
 open Exercise
@@ -10,9 +11,6 @@ open Exercise
 type Acronym() =
     inherit GeneratorExercise()
 
-type AtbashCipher() =
-    inherit GeneratorExercise()
-
 type AllYourBase() =    
     inherit GeneratorExercise()
 
@@ -31,12 +29,13 @@ type Allergies() =
     override this.RenderTestMethodBody canonicalDataCase =
         if (canonicalDataCase.Property = "allergicTo") then
             let renderAssertion (jToken: JToken) =
-                let updatedProperties =
-                    canonicalDataCase.Properties
+                let updatedInput =
+                    canonicalDataCase.Input
                     |> Map.add "substance" (jToken.["substance"] |> toAllergen |> box)
-                    |> Map.add "expected" (jToken.["result"].ToObject<bool>() |> box)
 
-                { canonicalDataCase with Properties = updatedProperties }                
+                { canonicalDataCase with 
+                    Input = updatedInput
+                    Expected = jToken.["result"].ToObject<bool>() |> box }
                 |> this.RenderAssert
                 |> indent 1
 
@@ -90,18 +89,15 @@ type Anagram() =
 type ArmstrongNumbers() =
     inherit GeneratorExercise()
 
-    override __.RenderInput (_, _, value) =
-        (value :?> JToken).Value("number") 
-        |> formatValue
+type AtbashCipher() =
+    inherit GeneratorExercise()
 
 type BeerSong() =
     inherit GeneratorExercise()
 
-    override __.PropertiesUsedAsSutParameter _ = ["startBottles"; "takeDown"]
-
     override __.PropertiesWithIdentifier _ = ["expected"]
 
-    override __.RenderExpected (_, key, value) =
+    override __.RenderExpected (_, _, value) =
         (value :?> JArray)
         |> normalizeJArray
         |> Seq.map formatValue
@@ -148,10 +144,10 @@ type Change() =
 
     override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
 
-    override __.IdentifierTypeAnnotation (canonicalDataCase, key, _) = 
-        match key with 
-        | "expected" -> 
-            match canonicalDataCase.Properties.["target"] :?> int64 with
+    override __.IdentifierTypeAnnotation (canonicalDataCase, key, _) =
+        match key with
+        | "expected" ->
+            match canonicalDataCase.Input.["target"] :?> int64 with
             | 0L -> Some "int list option"
             | _  -> None
         | _ -> None
@@ -329,6 +325,9 @@ type Etl() =
 
     override this.RenderExpected (_, _, value) = this.FormatMap<char, int> value
 
+    override __.MapCanonicalDataCaseInput (canonicalDataCase, _) = 
+        Map.empty |> Map.add "lettersByScore" (canonicalDataCase.Properties.["input"])
+
     override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
 
 type FoodChain() =
@@ -487,38 +486,37 @@ type Markdown() =
 type Meetup() =
     inherit GeneratorExercise()
 
-    override __.RenderExpected (canonicalDataCase, _, _) =
-        let year  = canonicalDataCase.Properties.["year"] :?> int64 |> int
-        let month = canonicalDataCase.Properties.["month"] :?> int64 |> int
-        let day   = canonicalDataCase.Properties.["dayofmonth"] :?> int64 |> int
-        DateTime(year, month, day) |> formatDateTime |> parenthesize
+    override __.RenderExpected (_, _, value) =
+        DateTime.Parse(string value) 
+        |> formatDateTime 
+        |> parenthesize
 
     override __.RenderInput (canonicalDataCase, key, value) =
         match key with
         | "dayofweek" -> 
-            sprintf "DayOfWeek.%s" (string canonicalDataCase.Properties.["dayofweek"])
+            sprintf "DayOfWeek.%s" (string canonicalDataCase.Input.["dayofweek"])
         | "week" -> 
-            sprintf "Schedule.%s" (string canonicalDataCase.Properties.["week"] |> String.upperCaseFirst)
+            sprintf "Week.%s" (string canonicalDataCase.Input.["week"] |> String.upperCaseFirst)
         | _ -> 
             base.RenderInput (canonicalDataCase, key, value)
 
-    override __.MapCanonicalDataCaseProperties (_, properties) =
-        properties |> Map.add "expected" null // Ensure that the "expected" key exists
-
-    override __.PropertiesUsedAsSutParameter _ = 
-        ["year"; "month"; "dayofweek"; "week"]
+    override __.PropertiesUsedAsSutParameter _ = ["year"; "month"; "week"; "dayofweek"]
 
     override __.AdditionalNamespaces = [typeof<DateTime>.Namespace]
 
 type Minesweeper() =
     inherit GeneratorExercise()
 
-    override __.RenderValueWithoutIdentifier (_, _, value) =        
+    let renderValue (value: obj) = 
         value :?> JArray
         |> normalizeJArray
         |> Seq.map formatValue
         |> formatMultiLineList
 
+    override __.RenderInput (_, _, value) = renderValue value
+
+    override __.RenderExpected (_, _, value) = renderValue value
+
     override this.PropertiesWithIdentifier canonicalDataCase = this.Properties canonicalDataCase
 
     override __.IdentifierTypeAnnotation (_, _, value) = 
@@ -691,10 +689,10 @@ type Proverb() =
 type QueenAttack() =
     inherit GeneratorExercise()
 
-    override __.MapCanonicalDataCaseProperty (canonicalDataCase, key, value) =
-        match canonicalDataCase.Property, key, value with
-        | "create", "expected", _ -> value :?> int64 <> -1L |> box
-        | _ -> base.MapCanonicalDataCaseProperty (canonicalDataCase, key, value)
+    override __.MapCanonicalDataCaseExpected (canonicalDataCase, key, value) =
+        match canonicalDataCase.Property with
+        | "create" -> value :?> int64 <> -1L |> box
+        | _ -> base.MapCanonicalDataCaseInputProperty (canonicalDataCase, key, value)
 
     override __.RenderInput (canonicalDataCase, key, value) =
         let parsePositionTuple (tupleValue: obj) =
@@ -828,94 +826,61 @@ type ReverseString() =
 type RobotSimulator() =
     inherit GeneratorExercise()
 
-    let resultIdentifierName = "actual"
+    let parseInput (input: obj) = 
+        let token = input :?> JToken
+        let direction = token.SelectToken "direction" |> Option.ofObj
+        let position  = token.SelectToken "position"  |> Option.ofObj
+        (direction, position)
 
-    override __.PropertiesWithIdentifier _ = ["robot"; "property"; "expected"]
+    let renderDirection (value: JToken) = 
+        value.ToObject<string>() |> String.upperCaseFirst
 
-    member private __.RenderDirection (value: JToken) = 
-        sprintf "%s" (value.ToObject<string>() |> String.upperCaseFirst)  
-
-    member private __.RenderCoords (coords: JToken) = 
-        (coords.["x"].ToObject<int>(), coords.["y"].ToObject<int>()) 
+    let renderPosition (position: JToken) = 
+        (position.["x"].ToObject<int>(), position.["y"].ToObject<int>()) 
         |> formatValue
 
-    member private this.DefineRobot (direction: JToken) (coords: JToken) = 
-        sprintf "createRobot %s %s" (this.RenderDirection direction) (this.RenderCoords coords)
+    let renderRobot direction position = 
+        sprintf "create %s %s" (renderDirection direction) (renderPosition position)
 
-    member private __.GetRobotProperties (value : JToken) = 
-        value.SelectToken("direction"), value.SelectToken("position")
+    let renderInput input = 
+        match input with
+        | None,           Some position -> renderPosition position
+        | Some direction, None          -> renderDirection direction
+        | Some direction, Some position -> renderRobot direction position
+        | None,           None          -> failwith "No direction or position"
 
-    override __.RenderArrange canonicalDataCase =
-        // one identifier may be empty if we only checking created object
-        // we need to filter out this empty line
-        base.RenderArrange canonicalDataCase
-        |> List.choose (
-            function
-            | "" -> None
-            | v -> Some v
-        )
+    override __.PropertiesWithIdentifier canonicalDataCase =
+        match parseInput canonicalDataCase.Expected with
+        | None,   Some _ -> ["robot"; "sut"] 
+        | Some _, None   -> ["robot"; "sut"]
+        | Some _, Some _ -> ["robot"; "expected"]
+        | None,   None   -> ["robot"; "sut"; "expected"]
+
+    override __.ToTestMethodBodyAssert canonicalDataCase =
+        let testMethodBodyAssert = base.ToTestMethodBodyAssert(canonicalDataCase)
 
-    override this.RenderValueWithoutIdentifier (_, key, value) = 
+        match parseInput canonicalDataCase.Expected with
+        | None, Some _ -> { testMethodBodyAssert with Sut = sprintf "%s.position" testMethodBodyAssert.Sut }
+        | Some _, None -> { testMethodBodyAssert with Sut = sprintf "%s.direction" testMethodBodyAssert.Sut }
+        | _ -> testMethodBodyAssert
+
+    override __.RenderValueWithoutIdentifier (canonicalDataCase, key, value) = 
         match key with
-        | "robot" ->
-            let input = value :?> JToken
-            this.DefineRobot ("direction" |> input.SelectToken) ("position" |> input.SelectToken)
-        | "expected" -> 
-            // here we may need to render full robot object
-            // or just coordinate/direction values
-            let input = value :?> JToken
-            let direction, position = this.GetRobotProperties input
-            match isNull direction, isNull position with
-            | true, false ->
-                this.RenderCoords position
-            | false, true ->
-                this.RenderDirection direction
-            | false, false ->
-                this.DefineRobot ("direction" |> input.SelectToken) ("position" |> input.SelectToken)
-            | true, true -> 
-                ""
-        | _ -> ""
-
-    override __.RenderValueWithIdentifier (canonicalDataCase, key, value) = 
-        match key with 
-        | "property" -> 
-            let action = value :?> string
-            match action with 
-            | "instructions" -> 
-                 sprintf "let %s = simulate robot %s" resultIdentifierName (canonicalDataCase.Properties.["instructions"] |> formatValue)
-            | "create" -> 
-                ""
-            | _ -> 
-                 sprintf "let %s = %s robot" resultIdentifierName action
-            
-        | _ -> 
-            base.RenderValueWithIdentifier (canonicalDataCase, key, value)
+        | "robot"    -> value |> parseInput |> renderInput
+        | "expected" -> value |> parseInput |> renderInput
+        | _ -> base.RenderValueWithoutIdentifier (canonicalDataCase, key, value)
 
-    override this.RenderSut canonicalDataCase = 
+    override __.RenderSut canonicalDataCase = 
         match canonicalDataCase.Property with
-        | "create" -> 
-            "robot"
-        | _ -> 
-            // depends on expected value we may need to 
-            // check whole robot or just one of its' properties
-            let direction, position = this.GetRobotProperties (canonicalDataCase.Properties.["expected"] :?> JToken)
-            match isNull direction, isNull position with
-            | true, false -> 
-                sprintf "%s.coordinate" resultIdentifierName
-            | false, true ->
-                sprintf "%s.bearing" resultIdentifierName
-            | true, true -> 
-                resultIdentifierName
-            | false, false -> 
-                match canonicalDataCase.Property with
-                | "create" -> "robot"
-                | _ -> resultIdentifierName
-    
+        | "create" -> "robot"
+        | _ -> base.RenderSut canonicalDataCase
+
     override __.RenderTestMethodName canonicalDataCase =
-         // avoid duplicated method names
-         // for this generator it is preferable
-         // because useFullMethodName leads to very long names
-         sprintf "%s - %s" canonicalDataCase.Property (canonicalDataCase.Description |> String.upperCaseFirst)
+        let testMethodName = base.RenderTestMethodName canonicalDataCase
+
+        match canonicalDataCase.Property with
+        | "create" | "instructions" -> testMethodName
+        | _ -> sprintf "%s %s" canonicalDataCase.Property (String.lowerCaseFirst testMethodName)
 
 type RotationalCipher() =
     inherit GeneratorExercise()

data/tracks/haskell/exercises/alphametics/package.yaml

@@ -1,5 +1,5 @@
 name: alphametics
-version: 1.0.0.3
+version: 1.2.0.4
 
 dependencies:
   - base

data/tracks/haskell/exercises/alphametics/test/Tests.hs

@@ -63,6 +63,11 @@ cases = [ Case { description = "puzzle with three letters"
 --               , expected     = Just [('A', 5), ('D', 3), ('E', 4), ('F', 7), ('G', 8),
 --                                      ('N', 0), ('O', 2), ('R', 1), ('S', 6), ('T', 9)]
 --               }
+--        , Case { description = "puzzle with ten letters and 199 addends"
+--               , puzzle      = "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + TELL + A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS + A + LIE + THE + TALE + OF + THE + LAST + FIRE + HORSES + LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE + HORRORS + THE + LAST + FREE + TROLL + TERRIFIES + THE + HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE + HOLE + OF + LOSSES + IT + IS + THERE + THAT + SHE + STORES + ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + HER + HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS + SHE + HEARS + THE + LEAST + FAR + HORSE + THOSE + FAST + HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF + TO + THE + FOREST + THE + HORSES + THAT + ALERTS + RAISE + THE + STARES + OF + THE + OTHERS + AS + THE + TROLL + ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR + HOOF + OFF + TORSO + AS + THE + LAST + HORSE + FORFEITS + ITS + LIFE + THE + FIRST + FATHERS + HEAR + OF + THE + HORRORS + THEIR + FEARS + THAT + THE + FIRES + FOR + THEIR + FEASTS + ARREST + AS + THE + FIRST + FATHERS + RESETTLE + THE + LAST + OF + THE + FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE + FOREST + HEART + FREE + AT + LAST + OF + THE + LAST + TROLL + ALL + OFFER + THEIR + FIRE + HEAT + TO + THE + ASSISTERS + FAR + OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS + STARS + RISE + THE + HORSES + REST + SAFE + AFTER + ALL + SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A + ROOFS + FOR + THEIR + SAFE == FORTRESSES"
+--               , expected    = Just [('A', 1), ('E', 0), ('F', 5), ('H', 8), ('I', 7),
+--                                     ('L', 2), ('O', 6), ('R', 3), ('S', 4), ('T', 9)]
+--               }
 --        , Case { description  = "puzzle with multiplication"
 --               , puzzle       = "IF * DR == DORI"
 --               , expected     = Just [('I', 8), ('F', 2), ('D', 3), ('R', 9), ('O', 1)]

data/tracks/haskell/exercises/bowling/package.yaml

@@ -1,5 +1,5 @@
 name: bowling
-version: 1.0.1.4
+version: 1.1.0.5
 
 dependencies:
   - base

data/tracks/haskell/exercises/pangram/package.yaml

@@ -1,5 +1,5 @@
 name: pangram
-version: 1.3.0.5
+version: 1.4.0.6
 
 dependencies:
   - base

data/tracks/haskell/exercises/say/package.yaml

@@ -1,5 +1,5 @@
 name: say
-version: 1.0.0.3
+version: 1.1.0.4
 
 dependencies:
   - base

data/tracks/haskell/exercises/sum-of-multiples/package.yaml

@@ -1,5 +1,5 @@
 name: sum-of-multiples
-version: 1.1.0.4
+version: 1.2.0.5
 
 dependencies:
   - base

data/tracks/haskell/exercises/word-count/package.yaml

@@ -1,5 +1,5 @@
 name: word-count
-version: 1.0.0.3
+version: 1.1.0.4
 
 dependencies:
   - base

data/tracks/haskell/exercises/wordy/package.yaml

@@ -1,5 +1,5 @@
 name: wordy
-version: 1.0.0.3
+version: 1.1.0.4
 
 dependencies:
   - base

data/tracks/java/exercises/nucleotide-count/.meta/hints.md

@@ -0,0 +1,58 @@
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!

data/tracks/java/exercises/nucleotide-count/README.md

@@ -12,6 +12,68 @@ Here is an analogy:
 - legos are to lego houses as
 - words are to sentences as...
 
+# Java Tips
+
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!
+
+
 # Running the tests
 
 You can run all the tests for an exercise by entering