trackler 2.2.1.88 → 2.2.1.89

data/tracks/fsharp/exercises/robot-simulator/Example.fs

@@ -1,34 +1,34 @@
 module RobotSimulator
 
-type Bearing = North | East | South | West
-type Coordinate = int * int
+type Direction = North | East | South | West
+type Position = int * int
 
-type Robot = { bearing: Bearing; coordinate: Coordinate }
+type Robot = { direction: Direction; position: Position }
 
-let createRobot bearing coordinate = { bearing = bearing; coordinate = coordinate }
+let create bearing position = { direction = bearing; position = position }
 
 let turnLeft robot = 
-    match robot.bearing with
-    | North -> { robot with bearing = West  }
-    | East  -> { robot with bearing = North }
-    | South -> { robot with bearing = East  }
-    | West  -> { robot with bearing = South }
+    match robot.direction with
+    | North -> { robot with direction = West  }
+    | East  -> { robot with direction = North }
+    | South -> { robot with direction = East  }
+    | West  -> { robot with direction = South }
 
 let turnRight robot = 
-    match robot.bearing with
-    | North -> { robot with bearing = East  }
-    | East  -> { robot with bearing = South }
-    | South -> { robot with bearing = West  }
-    | West  -> { robot with bearing = North }
+    match robot.direction with
+    | North -> { robot with direction = East  }
+    | East  -> { robot with direction = South }
+    | South -> { robot with direction = West  }
+    | West  -> { robot with direction = North }
 
 let advance robot = 
-    let (x, y) = robot.coordinate
+    let (x, y) = robot.position
 
-    match robot.bearing with
-    | North -> { robot with coordinate = (x    , y + 1) }
-    | East  -> { robot with coordinate = (x + 1, y    ) }
-    | South -> { robot with coordinate = (x    , y - 1) }
-    | West  -> { robot with coordinate = (x - 1, y    ) }
+    match robot.direction with
+    | North -> { robot with position = (x    , y + 1) }
+    | East  -> { robot with position = (x + 1, y    ) }
+    | South -> { robot with position = (x    , y - 1) }
+    | West  -> { robot with position = (x - 1, y    ) }
     
 let applyInstruction robot instruction =
     match instruction with
@@ -37,4 +37,4 @@ let applyInstruction robot instruction =
     | 'A' -> advance robot
     | _   -> failwith "Invalid instruction"
 
-let simulate robot instructions = Seq.fold applyInstruction robot instructions
+let instructions instructions' robot = Seq.fold applyInstruction robot instructions'

data/tracks/fsharp/exercises/robot-simulator/RobotSimulator.fs

@@ -1,11 +1,11 @@
 module RobotSimulator
 
-type Bearing = North | East | South | West
-type Coordinate = int * int
+type Direction = North | East | South | West
+type Position = int * int
 
-type Robot = { bearing: Bearing; coordinate: Coordinate }
+type Robot = { direction: Direction; position: Position }
 
-let createRobot bearing coordinate = failwith "You need to implement this function."
+let create direction position = failwith "You need to implement this function."
 
 let turnLeft robot = failwith "You need to implement this function."
 
@@ -13,4 +13,4 @@ let turnRight robot = failwith "You need to implement this function."
 
 let advance robot = failwith "You need to implement this function."
 
-let simulate robot instructions = failwith "You need to implement this function."
+let instructions instructions' robot = failwith "You need to implement this function."

data/tracks/fsharp/exercises/robot-simulator/RobotSimulatorTest.fs

@@ -8,140 +8,122 @@ open Xunit
 open RobotSimulator
 
 [<Fact>]
-let ``create - Robots are created with a position and direction`` () =
-    let robot = createRobot North (0, 0)
-    let expected = createRobot North (0, 0)
+let ``Robots are created with a position and direction`` () =
+    let robot = create North (0, 0)
+    let expected = create North (0, 0)
     robot |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``create - Negative positions are allowed`` () =
-    let robot = createRobot South (-1, -1)
-    let expected = createRobot South (-1, -1)
+let ``Negative positions are allowed`` () =
+    let robot = create South (-1, -1)
+    let expected = create South (-1, -1)
     robot |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnRight - Does not change the position`` () =
-    let robot = createRobot North (0, 0)
-    let actual = turnRight robot
-    let expected = (0, 0)
-    actual.coordinate |> should equal expected
+let ``turnRight does not change the position`` () =
+    let robot = create North (0, 0)
+    let sut = turnRight robot
+    sut.position |> should equal (0, 0)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnRight - Changes the direction from north to east`` () =
-    let robot = createRobot North (0, 0)
-    let actual = turnRight robot
-    let expected = East
-    actual.bearing |> should equal expected
+let ``turnRight changes the direction from north to east`` () =
+    let robot = create North (0, 0)
+    let sut = turnRight robot
+    sut.direction |> should equal East
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnRight - Changes the direction from east to south`` () =
-    let robot = createRobot East (0, 0)
-    let actual = turnRight robot
-    let expected = South
-    actual.bearing |> should equal expected
+let ``turnRight changes the direction from east to south`` () =
+    let robot = create East (0, 0)
+    let sut = turnRight robot
+    sut.direction |> should equal South
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnRight - Changes the direction from south to west`` () =
-    let robot = createRobot South (0, 0)
-    let actual = turnRight robot
-    let expected = West
-    actual.bearing |> should equal expected
+let ``turnRight changes the direction from south to west`` () =
+    let robot = create South (0, 0)
+    let sut = turnRight robot
+    sut.direction |> should equal West
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnRight - Changes the direction from west to north`` () =
-    let robot = createRobot West (0, 0)
-    let actual = turnRight robot
-    let expected = North
-    actual.bearing |> should equal expected
+let ``turnRight changes the direction from west to north`` () =
+    let robot = create West (0, 0)
+    let sut = turnRight robot
+    sut.direction |> should equal North
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnLeft - Does not change the position`` () =
-    let robot = createRobot North (0, 0)
-    let actual = turnLeft robot
-    let expected = (0, 0)
-    actual.coordinate |> should equal expected
+let ``turnLeft does not change the position`` () =
+    let robot = create North (0, 0)
+    let sut = turnLeft robot
+    sut.position |> should equal (0, 0)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnLeft - Changes the direction from north to west`` () =
-    let robot = createRobot North (0, 0)
-    let actual = turnLeft robot
-    let expected = West
-    actual.bearing |> should equal expected
+let ``turnLeft changes the direction from north to west`` () =
+    let robot = create North (0, 0)
+    let sut = turnLeft robot
+    sut.direction |> should equal West
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnLeft - Changes the direction from west to south`` () =
-    let robot = createRobot West (0, 0)
-    let actual = turnLeft robot
-    let expected = South
-    actual.bearing |> should equal expected
+let ``turnLeft changes the direction from west to south`` () =
+    let robot = create West (0, 0)
+    let sut = turnLeft robot
+    sut.direction |> should equal South
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnLeft - Changes the direction from south to east`` () =
-    let robot = createRobot South (0, 0)
-    let actual = turnLeft robot
-    let expected = East
-    actual.bearing |> should equal expected
+let ``turnLeft changes the direction from south to east`` () =
+    let robot = create South (0, 0)
+    let sut = turnLeft robot
+    sut.direction |> should equal East
 
 [<Fact(Skip = "Remove to run test")>]
-let ``turnLeft - Changes the direction from east to north`` () =
-    let robot = createRobot East (0, 0)
-    let actual = turnLeft robot
-    let expected = North
-    actual.bearing |> should equal expected
+let ``turnLeft changes the direction from east to north`` () =
+    let robot = create East (0, 0)
+    let sut = turnLeft robot
+    sut.direction |> should equal North
 
 [<Fact(Skip = "Remove to run test")>]
-let ``advance - Does not change the direction`` () =
-    let robot = createRobot North (0, 0)
-    let actual = advance robot
-    let expected = North
-    actual.bearing |> should equal expected
+let ``advance does not change the direction`` () =
+    let robot = create North (0, 0)
+    let sut = advance robot
+    sut.direction |> should equal North
 
 [<Fact(Skip = "Remove to run test")>]
-let ``advance - Increases the y coordinate one when facing north`` () =
-    let robot = createRobot North (0, 0)
-    let actual = advance robot
-    let expected = (0, 1)
-    actual.coordinate |> should equal expected
+let ``advance increases the y coordinate one when facing north`` () =
+    let robot = create North (0, 0)
+    let sut = advance robot
+    sut.position |> should equal (0, 1)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``advance - Decreases the y coordinate by one when facing south`` () =
-    let robot = createRobot South (0, 0)
-    let actual = advance robot
-    let expected = (0, -1)
-    actual.coordinate |> should equal expected
+let ``advance decreases the y coordinate by one when facing south`` () =
+    let robot = create South (0, 0)
+    let sut = advance robot
+    sut.position |> should equal (0, -1)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``advance - Increases the x coordinate by one when facing east`` () =
-    let robot = createRobot East (0, 0)
-    let actual = advance robot
-    let expected = (1, 0)
-    actual.coordinate |> should equal expected
+let ``advance increases the x coordinate by one when facing east`` () =
+    let robot = create East (0, 0)
+    let sut = advance robot
+    sut.position |> should equal (1, 0)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``advance - Decreases the x coordinate by one when facing west`` () =
-    let robot = createRobot West (0, 0)
-    let actual = advance robot
-    let expected = (-1, 0)
-    actual.coordinate |> should equal expected
+let ``advance decreases the x coordinate by one when facing west`` () =
+    let robot = create West (0, 0)
+    let sut = advance robot
+    sut.position |> should equal (-1, 0)
 
 [<Fact(Skip = "Remove to run test")>]
-let ``instructions - Instructions to move west and north`` () =
-    let robot = createRobot North (0, 0)
-    let actual = simulate robot "LAAARALA"
-    let expected = createRobot West (-4, 1)
-    actual |> should equal expected
+let ``Instructions to move west and north`` () =
+    let robot = create North (0, 0)
+    let expected = create West (-4, 1)
+    instructions "LAAARALA" robot |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``instructions - Instructions to move west and south`` () =
-    let robot = createRobot East (2, -7)
-    let actual = simulate robot "RRAAAAALA"
-    let expected = createRobot South (-3, -8)
-    actual |> should equal expected
+let ``Instructions to move west and south`` () =
+    let robot = create East (2, -7)
+    let expected = create South (-3, -8)
+    instructions "RRAAAAALA" robot |> should equal expected
 
 [<Fact(Skip = "Remove to run test")>]
-let ``instructions - Instructions to move east and north`` () =
-    let robot = createRobot South (8, 4)
-    let actual = simulate robot "LAAARRRALLLL"
-    let expected = createRobot North (11, 5)
-    actual |> should equal expected
+let ``Instructions to move east and north`` () =
+    let robot = create South (8, 4)
+    let expected = create North (11, 5)
+    instructions "LAAARRRALLLL" robot |> should equal expected
 

data/tracks/fsharp/generators/CanonicalData.fs

@@ -9,6 +9,23 @@ open Newtonsoft.Json
 open Newtonsoft.Json.Linq
 open Options
 
+type CanonicalDataCase = 
+    { Input: Map<string, obj>
+      Expected: obj
+      Property: string
+      Properties: Map<string, obj>
+      Description: string
+      DescriptionPath: string list }
+
+type CanonicalData = 
+    { Exercise: string
+      Version: string
+      Cases: CanonicalDataCase list }
+
+type CanonicalDataFormat = 
+    | Old
+    | New
+
 let [<Literal>] private ProblemSpecificationsGitUrl = "https://github.com/exercism/problem-specifications.git";
 let [<Literal>] private ProblemSpecificationsBranch = "master";
 let [<Literal>] private ProblemSpecificationsRemote = "origin";
@@ -46,7 +63,7 @@ let private downloadData options =
 type CanonicalDataConverter() =
     inherit JsonConverter()
 
-    let createCanonicalDataCasePropertiesFromJToken (jToken: JToken) =
+    let jTokenToMap (jToken: JToken) =
         jToken.ToObject<IDictionary<string, obj>>()
         |> Dict.toMap
 
@@ -60,8 +77,32 @@ type CanonicalDataConverter() =
         |> Json.parentsAndSelf
         |> List.choose descriptionFromJToken
 
+    let createInputFromJTokenInNewFormat (properties: Map<string, obj>) = 
+        (properties.["input"] :?> JObject)
+        |> jTokenToMap
+
+    let createInputFromJTokenInOldFormat (properties: Map<string, obj>) = 
+        properties
+        |> Map.filter (fun key _ -> List.contains key ["expected"; "property"; "description"; "comments"] |> not)
+
+    let detectCanonicalDataFormatFromJToken (properties: Map<string, obj>) = 
+        match properties.ContainsKey "input" && properties.["input"] :? JObject with
+        | true  -> New
+        | false -> Old
+
+    let createInputFromJToken (properties: Map<string, obj>) = 
+        match detectCanonicalDataFormatFromJToken properties with
+        | Old -> createInputFromJTokenInOldFormat properties
+        | New -> createInputFromJTokenInNewFormat properties
+
     let createCanonicalDataCaseFromJToken (jToken: JToken) =
-        { Properties = createCanonicalDataCasePropertiesFromJToken jToken
+        let properties = jTokenToMap jToken
+
+        { Input = createInputFromJToken properties
+          Expected = properties.["expected"]
+          Property = string properties.["property"]
+          Properties = properties
+          Description = string properties.["description"]
           DescriptionPath = createDescriptionPathFromJToken jToken }
 
     let createCanonicalDataCasesFromJToken (jToken: JToken) =  
@@ -83,7 +124,8 @@ type CanonicalDataConverter() =
     override __.CanConvert(objectType: Type) = objectType = typeof<CanonicalData>
 
 let private convertCanonicalData canonicalDataContents = 
-    JsonConvert.DeserializeObject<CanonicalData>(canonicalDataContents, CanonicalDataConverter())     
+    let converter = CanonicalDataConverter()
+    JsonConvert.DeserializeObject<CanonicalData>(canonicalDataContents, converter)
 
 let private canonicalDataFile options exercise = 
     Path.Combine(options.CanonicalDataDirectory, "exercises", exercise, "canonical-data.json")
@@ -98,4 +140,8 @@ let hasCanonicalData options exercise =
 
 let parseCanonicalData options = 
     downloadData options 
-    readCanonicalData options >> convertCanonicalData
+
+    fun exercise ->
+        exercise 
+        |> readCanonicalData options 
+        |> convertCanonicalData

data/tracks/fsharp/generators/Common.fs

@@ -5,19 +5,6 @@ open System
 open Serilog
 open Newtonsoft.Json.Linq
 
-type CanonicalDataCase = 
-    { Properties: Map<string, obj>
-      DescriptionPath: string list } with 
-        member this.Description = string this.Properties.["description"]
-        member this.Property = string this.Properties.["property"]
-        member this.Expected = this.Properties.["expected"]
-        member this.Input = this.Properties.["input"]
-
-type CanonicalData = 
-    { Exercise: string
-      Version: string
-      Cases: CanonicalDataCase list }
-
 type TestMethod = 
     { Skip: bool
       Name: string
@@ -94,6 +81,10 @@ module String =
         | "" -> str
         | _  -> sprintf "%c%s" (Char.ToUpper(str.[0])) str.[1..]
 
+    let lowerCaseFirst (str: string) = 
+        match str with
+        | "" -> str
+        | _  -> sprintf "%c%s" (Char.ToLower(str.[0])) str.[1..]
 
 module Json =
     let rec parentsAndSelf (currentToken: JToken) =

data/tracks/fsharp/generators/Exercise.fs

@@ -19,8 +19,9 @@ type GeneratorExercise() =
     // Allow changes in canonical data
     abstract member MapCanonicalData : CanonicalData -> CanonicalData
     abstract member MapCanonicalDataCase : CanonicalDataCase -> CanonicalDataCase
-    abstract member MapCanonicalDataCaseProperties : CanonicalDataCase * Map<string, obj> -> Map<string, obj>
-    abstract member MapCanonicalDataCaseProperty : CanonicalDataCase * string * obj -> obj
+    abstract member MapCanonicalDataCaseInput : CanonicalDataCase * Map<string, obj> -> Map<string, obj>
+    abstract member MapCanonicalDataCaseInputProperty : CanonicalDataCase * string * obj -> obj
+    abstract member MapCanonicalDataCaseExpected : CanonicalDataCase * string * obj -> obj
 
     // Convert canonical data to representation used when rendering
     abstract member ToTestFile : CanonicalData -> TestFile
@@ -91,13 +92,16 @@ type GeneratorExercise() =
 
     default this.MapCanonicalDataCase canonicalDataCase =
         { canonicalDataCase with 
-            Properties = this.MapCanonicalDataCaseProperties (canonicalDataCase, canonicalDataCase.Properties) }
+            Input = this.MapCanonicalDataCaseInput (canonicalDataCase, canonicalDataCase.Input)
+            Expected = this.MapCanonicalDataCaseExpected (canonicalDataCase, "expected", canonicalDataCase.Expected) }
 
-    default this.MapCanonicalDataCaseProperties (canonicalDataCase, properties) =
+    default this.MapCanonicalDataCaseInput (canonicalDataCase, properties) =
         properties
-        |> Map.map (fun key value -> this.MapCanonicalDataCaseProperty (canonicalDataCase, key, value)) 
+        |> Map.map (fun key value -> this.MapCanonicalDataCaseInputProperty (canonicalDataCase, key, value)) 
 
-    default __.MapCanonicalDataCaseProperty (_, _, value) = value
+    default __.MapCanonicalDataCaseInputProperty (_, _, value) = value
+
+    default __.MapCanonicalDataCaseExpected (_, _, value) = value
 
     // Convert canonical data to representation used when rendering
 
@@ -122,7 +126,7 @@ type GeneratorExercise() =
           Assert = this.RenderAssert canonicalDataCase }
 
     default this.ToTestMethodBodyAssert canonicalDataCase =         
-        { Sut = this.RenderSut canonicalDataCase
+        { Sut = this.RenderValueOrIdentifier (canonicalDataCase, "sut", canonicalDataCase.Expected)
           Expected = this.RenderValueOrIdentifier (canonicalDataCase, "expected", canonicalDataCase.Expected) }
 
     // Determine the templates to use when rendering
@@ -195,6 +199,7 @@ type GeneratorExercise() =
     default this.RenderValueWithoutIdentifier (canonicalDataCase, key, value) = 
         match key with
         | "expected" -> this.RenderExpected (canonicalDataCase, key, value)
+        | "sut" -> this.RenderSut canonicalDataCase
         | _  -> this.RenderInput (canonicalDataCase, key, value)
 
     default this.RenderValueWithIdentifier (canonicalDataCase, key, value) = 
@@ -220,10 +225,22 @@ type GeneratorExercise() =
     default this.RenderInput (canonicalDataCase, key, value) = this.RenderValue (canonicalDataCase, key, value)
 
     default this.RenderArrange canonicalDataCase =
-        let renderArrangeProperty property: string option = 
-            match Map.tryFind property canonicalDataCase.Properties with
+        let renderExpected prop =
+            this.RenderValueWithIdentifier (canonicalDataCase, prop, canonicalDataCase.Expected) |> Some
+
+        let renderSut prop =
+            this.RenderValueWithIdentifier (canonicalDataCase, prop, canonicalDataCase.Expected) |> Some
+
+        let renderInput prop =
+            match Map.tryFind prop canonicalDataCase.Input with
             | None -> None
-            | Some value -> Some (this.RenderValueWithIdentifier (canonicalDataCase, property, value))
+            | Some value -> Some (this.RenderValueWithIdentifier (canonicalDataCase, prop, value))
+
+        let renderArrangeProperty prop: string option = 
+            match prop with
+            | "expected" -> renderExpected prop
+            | "sut" -> renderSut prop
+            | _ -> renderInput prop
 
         canonicalDataCase
         |> this.PropertiesWithIdentifier 
@@ -238,12 +255,12 @@ type GeneratorExercise() =
 
     default this.RenderSut canonicalDataCase = 
         let parameters = this.RenderSutParameters canonicalDataCase
-        let property = this.RenderSutProperty canonicalDataCase
-        property :: parameters |> String.concat " "
+        let prop = this.RenderSutProperty canonicalDataCase
+        prop :: parameters |> String.concat " "
 
     default this.RenderSutParameters canonicalDataCase =
         let sutParameterProperties = this.PropertiesUsedAsSutParameter canonicalDataCase
-        let renderSutParameter key = this.RenderSutParameter (canonicalDataCase, key, Map.find key canonicalDataCase.Properties)
+        let renderSutParameter key = this.RenderSutParameter (canonicalDataCase, key, Map.find key canonicalDataCase.Input)
 
         sutParameterProperties
         |> List.map renderSutParameter
@@ -257,10 +274,9 @@ type GeneratorExercise() =
         List.append (this.PropertiesUsedAsSutParameter canonicalDataCase) ["expected"]
 
     default __.PropertiesUsedAsSutParameter canonicalDataCase = 
-        canonicalDataCase.Properties
+        canonicalDataCase.Input
         |> Map.toList
         |> List.map fst
-        |> List.except ["expected"; "property"; "description"; "comments"]
     
     // Utility methods to customize rendered output