trackler 2.2.1.147 → 2.2.1.148

data/tracks/elixir/exercises/largest-series-product/example.exs

@@ -36,7 +36,7 @@ defmodule Series do
   end
 
   # Handle Enum.chunks -> Enum.chunk renaming.
-  if not ({:chunk, 3} in Enum.__info__(:functions)) do
+  if {:chunk, 3} not in Enum.__info__(:functions) do
     defp chunk(coll, n, step), do: Enum.chunks(coll, n, step)
   else
     defp chunk(coll, n, step), do: Enum.chunk(coll, n, step)

data/tracks/elm/exercises/phone-number/PhoneNumber.elm

@@ -1,11 +1,6 @@
-module PhoneNumber exposing (getNumber, prettyPrint)
+module PhoneNumber exposing (getNumber)
 
 
 getNumber : String -> Maybe String
 getNumber phoneNumber =
     Debug.crash "Please implement this function"
-
-
-prettyPrint : String -> Maybe String
-prettyPrint input =
-    Debug.crash "Please implement this function"

data/tracks/elm/exercises/phone-number/tests/Tests.elm

@@ -1,67 +1,52 @@
 module Tests exposing (..)
 
 import Expect
-import PhoneNumber exposing (getNumber, prettyPrint)
+import PhoneNumber exposing (getNumber)
 import Test exposing (..)
 
 
 tests : Test
 tests =
     describe "PhoneNumber"
-        [ test "cleans number" <|
+        [ test "cleans the number" <|
             \() -> Expect.equal (Just "2234567890") (getNumber "(223) 456-7890")
         , skip <|
-            test "invalid when empty" <|
-                \() -> Expect.equal Nothing (getNumber "")
-        , skip <|
-            test "cleans number with dots" <|
+            test "cleans numbers with dots" <|
                 \() -> Expect.equal (Just "2234567890") (getNumber "223.456.7890")
+        , skip <|
+            test "cleans numbers with multiple spaces" <|
+                \() -> Expect.equal (Just "2234567890") (getNumber "223 456   7890   ")
         , skip <|
             test "invalid when 9 digits" <|
                 \() -> Expect.equal Nothing (getNumber "223456789")
         , skip <|
-            test "cleans number with multiple spaces" <|
-                \() -> Expect.equal (Just "2234567890") (getNumber "223 456   7890")
-        , skip <|
-            test "invalid when 12 digits" <|
-                \() -> Expect.equal Nothing (getNumber "223456789012")
+            test "invalid when 11 digits does not start with a 1" <|
+                \() -> Expect.equal Nothing (getNumber "22234567890")
         , skip <|
-            test "valid when 11 digits and first is 1" <|
+            test "valid when 11 digits and starting with 1" <|
                 \() -> Expect.equal (Just "2234567890") (getNumber "12234567890")
         , skip <|
-            test "invalid when 11 digits and first is not 1" <|
-                \() -> Expect.equal Nothing (getNumber "22234567890")
-        , skip <|
-            test "valid when 11 digits and first is 1 with punctuation" <|
+            test "valid when 11 digits and starting with 1 even with punctuation" <|
                 \() -> Expect.equal (Just "2234567890") (getNumber "+1 (223) 456-7890")
+        , skip <|
+            test "invalid when more than 11 digits" <|
+                \() -> Expect.equal Nothing (getNumber "321234567890")
         , skip <|
             test "invalid with letters" <|
-                \() -> Expect.equal Nothing (getNumber "223-abc-789012")
+                \() -> Expect.equal Nothing (getNumber "123-abc-7890")
         , skip <|
-            test "invalid with multiple punctuation marks" <|
-                \() -> Expect.equal Nothing (getNumber "223-@:!-789012")
+            test "invalid with punctuations" <|
+                \() -> Expect.equal Nothing (getNumber "123-@:!-7890")
         , skip <|
-            test "invalid when area code starts with 1" <|
-                \() -> Expect.equal Nothing (getNumber "(123) 456-7890")
-        , skip <|
-            test "invalid when area code starts with 0" <|
+            test "invalid if area code starts with 0" <|
                 \() -> Expect.equal Nothing (getNumber "(023) 456-7890")
         , skip <|
-            test "invalid when exchange code starts with 1" <|
-                \() -> Expect.equal Nothing (getNumber "(223) 156-7890")
+            test "invalid if area code starts with 1" <|
+                \() -> Expect.equal Nothing (getNumber "(123) 456-7890")
         , skip <|
-            test "invalid when exchange code starts with 0" <|
+            test "invalid if exchange code starts with 0" <|
                 \() -> Expect.equal Nothing (getNumber "(223) 056-7890")
         , skip <|
-            test "invalid when N in exchange code is 1" <|
-                \() -> Expect.equal Nothing (getNumber "2341567890")
-        , skip <|
-            test "invalid when no digits present" <|
-                \() -> Expect.equal Nothing (getNumber " (-) ")
-        , skip <|
-            test "pretty print" <|
-                \() -> Expect.equal (Just "(223) 456-7890") (prettyPrint "2234567890")
-        , skip <|
-            test "pretty print with full us phone number" <|
-                \() -> Expect.equal (Just "(223) 456-7890") (prettyPrint "12234567890")
+            test "invalid if exchange code starts with 1" <|
+                \() -> Expect.equal Nothing (getNumber "(223) 156-7890")
         ]

data/tracks/elm/exercises/run-length-encoding/tests/Tests.elm

@@ -10,35 +10,59 @@ tests =
     describe "RunLengthEncoding"
         [ test "the solution is for the correct version of the test" <|
             \() -> Expect.equal 2 version
-        , test "encode simple" <|
-            \() -> Expect.equal "2A3B4C" (encode "AABBBCCCC")
-        , skip <|
-            test "decode simple" <|
-                \() -> Expect.equal "AABBBCCCC" (decode "2A3B4C")
-        , skip <|
-            test "encode with single values" <|
-                \() ->
-                    Expect.equal "12WB12W3B24WB"
-                        (encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB")
-        , skip <|
-            test "decode with single values" <|
-                \() ->
-                    Expect.equal "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
-                        (decode "12WB12W3B24WB")
-        , skip <|
-            test "(decode (encode (...)) combination" <|
-                \() ->
-                    Expect.equal "zzz ZZ  zZ"
-                        (decode (encode "zzz ZZ  zZ"))
-        , skip <|
-            test "decode with a x10 value" <|
-                \() ->
-                    Expect.equal "WWWWWWWWWW"
-                        (decode "10W")
-        , skip <|
-            test "encode unicode" <|
-                \() -> Expect.equal "⏰3⚽2⭐⏰" (encode "⏰⚽⚽⚽⭐⭐⏰")
-        , skip <|
-            test "decode unicode" <|
-                \() -> Expect.equal "⏰⚽⚽⚽⭐⭐⏰" (decode "⏰3⚽2⭐⏰")
+        , describe "run-length encode a string"
+            [ test "empty string" <|
+                \() -> Expect.equal "" (encode "")
+            , skip <|
+                test "single characters only are encoded without count" <|
+                    \() -> Expect.equal "XYZ" (encode "XYZ")
+            , skip <|
+                test "string with no single characters" <|
+                    \() -> Expect.equal "2A3B4C" (encode "AABBBCCCC")
+            , skip <|
+                test "single characters mixed with repeated characters" <|
+                    \() ->
+                        Expect.equal "12WB12W3B24WB"
+                            (encode "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB")
+            , skip <|
+                test "multiple whitespace mixed in string" <|
+                    \() -> Expect.equal "2 hs2q q2w2 " (encode "  hsqq qww  ")
+            , skip <|
+                test "lowercase characters" <|
+                    \() -> Expect.equal "2a3b4c" (encode "aabbbcccc")
+            ]
+        , describe "run-length decode a string"
+            [ skip <|
+                test "empty string" <|
+                    \() -> Expect.equal "" (decode "")
+            , skip <|
+                test "single characters only" <|
+                    \() -> Expect.equal "XYZ" (decode "XYZ")
+            , skip <|
+                test "string with no single characters" <|
+                    \() -> Expect.equal "AABBBCCCC" (decode "2A3B4C")
+            , skip <|
+                test "single characters with repeated characters" <|
+                    \() ->
+                        Expect.equal "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"
+                            (decode "12WB12W3B24WB")
+            , skip <|
+                test "multiple whitespace mixed in string" <|
+                    \() -> Expect.equal "  hsqq qww  " (decode "2 hs2q q2w2 ")
+            , skip <|
+                test "lower case string" <|
+                    \() -> Expect.equal "" (decode "")
+            , skip <|
+                test "with a x10 value" <|
+                    \() ->
+                        Expect.equal "WWWWWWWWWW"
+                            (decode "10W")
+            ]
+        , describe "encode and then decode"
+            [ skip <|
+                test "encode followed by decode gives original string" <|
+                    \() ->
+                        Expect.equal "zzz ZZ  zZ"
+                            (decode (encode "zzz ZZ  zZ"))
+            ]
         ]

data/tracks/fsharp/generators/Exercise.fs

@@ -11,6 +11,11 @@ open Templates
 open CanonicalData
 open Track
 
+let [<Literal>] private AssertEmptyTemplate = "AssertEmpty"
+let [<Literal>] private AssertEqualTemplate = "AssertEqual"
+let [<Literal>] private AssertEqualWithinTemplate = "AssertEqualWithin"
+let [<Literal>] private AssertThrowsTemplate = "AssertThrows"
+
 let private exerciseNameFromType (exerciseType: Type) = exerciseType.Name.Kebaberize()
 
 [<AbstractClass>]
@@ -109,9 +114,25 @@ type GeneratorExercise() =
         let expectedHasIdentifier = List.contains "expected" (this.PropertiesWithIdentifier canonicalDataCase)
 
         if expectedIsArray && expectedIsEmpty && not expectedHasIdentifier then
-            "AssertEmpty"
+            AssertEmptyTemplate
         else        
-            "AssertEqual"
+            AssertEqualTemplate
+
+    member __.RenderAssertEmpty sut expected =
+        { Sut = sut; Expected = expected }
+        |> renderTemplate AssertEmptyTemplate 
+
+    member __.RenderAssertEqual sut expected =
+        { Sut = sut; Expected = expected }
+        |> renderTemplate AssertEqualTemplate
+
+    member __.RenderAssertEqualWithin sut expected =
+        { Sut = sut; Expected = expected }
+        |> renderTemplate AssertEqualWithinTemplate
+
+    member __.RenderAssertThrows sut expected =
+        { Sut = sut; Expected = expected }
+        |> renderTemplate AssertThrowsTemplate
 
     default __.TestFileFormat = TestFileFormat.Module
 
@@ -120,21 +141,21 @@ type GeneratorExercise() =
     member this.Render canonicalData =
         canonicalData
         |> this.ToTestFile
-        |> renderPartialTemplate this.TestFileTemplate
+        |> renderTemplate this.TestFileTemplate
 
     member this.RenderTestMethod (index, canonicalDataCase) = 
         let template = this.TestMethodTemplate (index, canonicalDataCase)
 
         (index, canonicalDataCase)
         |> this.ToTestMethod 
-        |> renderPartialTemplate template
+        |> renderTemplate template
 
     member this.RenderTestMethodBody canonicalDataCase = 
         let template = this.TestMethodBodyTemplate canonicalDataCase
 
         canonicalDataCase
         |> this.ToTestMethodBody
-        |> renderPartialTemplate template
+        |> renderTemplate template
 
     default this.TestMethodName canonicalDataCase = 
         match this.UseFullMethodName canonicalDataCase with
@@ -213,7 +234,7 @@ type GeneratorExercise() =
 
         canonicalDataCase
         |> this.ToTestMethodBodyAssert
-        |> renderPartialTemplate template
+        |> renderTemplate template
         |> List.singleton
 
     default this.RenderSut canonicalDataCase =

data/tracks/fsharp/generators/Generators.fs

@@ -28,20 +28,18 @@ type Allergies() =
 
     let renderAllergenEnum (jToken: JToken) = Obj.renderEnum "Allergen" jToken
 
-    let renderAllergicToAssert canonicalDataCase (jToken: JToken) =
+    member this.RenderAllergicToAssert canonicalDataCase (jToken: JToken) =
         let substance = renderAllergenEnum jToken.["substance"]
         let score = canonicalDataCase.Input.["score"].ToObject<int>()
         let sut = sprintf "allergicTo %d %s" score substance
         let expected = jToken.Value<bool>("result") |> Bool.render
-        
-        { Sut = sut; Expected = expected }
-        |> renderPartialTemplate "AssertEqual"
+        this.RenderAssertEqual sut expected
 
-    override __.RenderAssert canonicalDataCase =
+    override this.RenderAssert canonicalDataCase =
         match canonicalDataCase.Property with
         | "allergicTo" ->
             canonicalDataCase.Expected
-            |> Seq.map (renderAllergicToAssert canonicalDataCase)
+            |> Seq.map (this.RenderAllergicToAssert canonicalDataCase)
             |> Seq.toList
         | _ -> 
             base.RenderAssert canonicalDataCase
@@ -97,7 +95,7 @@ type BinarySearch() =
 type BinarySearchTree() =
     inherit GeneratorExercise()
 
-    let rec renderAssertions previousPaths (tree: JToken) =
+    member this.RenderAssertions previousPaths (tree: JToken) =
         let previousPath = previousPaths |> List.rev |> String.concat " |> "
         let rootPath = List.length previousPaths = 1
 
@@ -108,30 +106,30 @@ type BinarySearchTree() =
             match data.Type with
             | JTokenType.Null -> 
                 let expected = if rootPath then failwith "Invalid data" else "None"
-                [ sprintf "%s |> %s |> should equal %s" previousPath dataPath expected ]
+                [ this.RenderAssertEqual (sprintf "%s |> %s" previousPath dataPath) expected ]
             | _ -> 
                 let expected = if rootPath then string data else sprintf "(Some %s)" (string data)
-                [ sprintf "%s |> %s |> should equal %s" previousPath dataPath expected ]
+                [ this.RenderAssertEqual (sprintf "%s |> %s" previousPath dataPath) expected ]
 
         let renderNodeAssertions nodeName (node: JToken) = 
             let nodePath = if rootPath then nodeName else sprintf "Option.bind %s" nodeName
 
             match node.Type with
             | JTokenType.Null -> 
-                [ sprintf "%s |> %s |> should equal None" previousPath nodePath ]
+                [ this.RenderAssertEqual (sprintf "%s |> %s" previousPath nodePath) "None" ]
             | _ ->
-                renderAssertions (nodePath :: previousPaths) node
+                this.RenderAssertions (nodePath :: previousPaths) node
 
         [ renderDataAssertions
           renderNodeAssertions "left" tree.["left"] 
           renderNodeAssertions "right" tree.["right"] ]
         |> List.concat
 
-    override __.RenderAssert canonicalDataCase = 
+    override this.RenderAssert canonicalDataCase = 
         match canonicalDataCase.Property with
         | "data" ->
             canonicalDataCase.Expected
-            |> renderAssertions ["treeData"]
+            |> this.RenderAssertions ["treeData"]
         | _ -> base.RenderAssert canonicalDataCase
 
     override __.RenderInput (_, _, value) = 
@@ -211,8 +209,7 @@ type CircularBuffer() =
 
     override __.RenderAssert _ = []
 
-    member __.ExceptionCheck command = 
-        sprintf "(fun () -> %s |> ignore) |> should throw typeof<Exception>" command 
+    member this.ExceptionCheck command = this.RenderAssertThrows command typeof<Exception>.Name
 
     override this.RenderArrange canonicalDataCase = 
         seq {
@@ -243,16 +240,14 @@ type CircularBuffer() =
                             yield sprintf "let (val%i, _) = %s" ind command
                         else
                             yield sprintf "let (val%i, buffer%i) = %s" ind ind command
-                        yield sprintf "val%i |> should equal %i" ind expected
+                        yield this.RenderAssertEqual (sprintf "val%i" ind) (string expected)
                 | "overwrite" ->
                     yield sprintf "let buffer%i = forceWrite %i buffer%i" ind (dict.["item"].ToObject<int>()) (ind-1)
                 | "clear" -> 
                     yield sprintf "let buffer%i = clear buffer%i" ind (ind - 1) 
                 | _ -> ()
                 ind <- ind + 1
-
-        }
-        |> Seq.toList
+        } |> Seq.toList
 
 type Clock() =
     inherit GeneratorExercise()
@@ -316,12 +311,11 @@ type ComplexNumbers() =
         | JTokenType.Integer -> sprintf "%d.0" (value.ToObject<int>())
         | _ -> base.RenderValue (canonicalDataCase, key, value)
 
-    override __.RenderAssert canonicalDataCase = 
+    override this.RenderAssert canonicalDataCase = 
         match canonicalDataCase.Expected.Type with
         | JTokenType.Array ->
             let renderAssertion testedFunction expected =
-                { Sut = sprintf "%s sut" testedFunction; Expected = expected }
-                |> renderPartialTemplate "AssertEqualWithin"
+                this.RenderAssertEqualWithin (sprintf "%s sut" testedFunction) expected
 
             [ canonicalDataCase.Expected.[0] |> renderNumber |> renderAssertion "real"
               canonicalDataCase.Expected.[1] |> renderNumber |> renderAssertion "imaginary" ]
@@ -451,7 +445,7 @@ type DiffieHellman() =
             List.append arrange ["let privateKeys = [for _ in 0 .. 10 -> privateKey p]" ]
         | _ -> arrange
 
-    override __.RenderAssert canonicalDataCase =
+    override this.RenderAssert canonicalDataCase =
         match canonicalDataCase.Property with
         | "privateKeyIsInRange" ->
             let greaterThan = canonicalDataCase.Expected.["greaterThan"].ToObject<int>()
@@ -460,9 +454,9 @@ type DiffieHellman() =
             [ sprintf "privateKeys |> List.iter (fun x -> x |> should be (greaterThan %dI))" greaterThan;
               sprintf "privateKeys |> List.iter (fun x -> x |> should be (lessThan %s))" lessThan ]
         | "privateKeyIsRandom" -> 
-            [ "List.distinct privateKeys |> List.length |> should equal (List.length privateKeys)" ]
+            [ this.RenderAssertEqual "List.distinct privateKeys |> List.length" "(List.length privateKeys)" ]
         | "keyExchange" ->
-            [ "secretA |> should equal secretB" ]
+            [ this.RenderAssertEqual "secretA" "secretB" ]
         | _ -> base.RenderAssert canonicalDataCase
 
     override __.MapCanonicalDataCase canonicalDataCase =
@@ -647,7 +641,7 @@ type Grep() =
 
     override __.RenderExpected (_, _, value) = List.renderMultiLine value |> indentExpected
 
-    override __.RenderSetup _ = renderPartialTemplate "Generators/GrepSetup" Map.empty<string, obj>
+    override __.RenderSetup _ = renderTemplate "Generators/GrepSetup" Map.empty<string, obj>
 
     override __.RenderArrange canonicalDataCase =
         base.RenderArrange canonicalDataCase @ [""; "createFiles() |> ignore"]
@@ -1046,13 +1040,6 @@ type React() =
             )
             |> Seq.toList
         [ reactorVar ] @ cellVars
-     
-    let renderExpectedCellValueOperation (op: JToken) =
-        seq { 
-            let cellName = op.["cell"].ToObject<string>()
-            let expectedValue = op.["value"].ToObject<int>()
-            yield sprintf "%s.Value |> should equal %i" cellName expectedValue 
-        }
 
     let renderExpectedCallbacks (jToken: JToken) =
         match jToken with
@@ -1101,28 +1088,35 @@ type React() =
             let callbackName = op.["name"].ToObject<string>()
             yield sprintf "%s.Changed.RemoveHandler %sHandler" cellName callbackName
         }
+     
+    member this.RenderExpectedCellValueOperation (op: JToken) =
+        seq { 
+            let cellName = op.["cell"].ToObject<string>()
+            let expectedValue = op.["value"].ToObject<string>()
+            yield this.RenderAssertEqual (sprintf "%s.Value" cellName) expectedValue 
+        }
+
+    member this.RenderOperations canonicalDataCase = 
+        canonicalDataCase.Input.["operations"]
+        |> Seq.collect this.renderOperation
+        |> Seq.toList
 
-    let renderOperation (op: JToken) =
+    member this.renderOperation (op: JToken) =
         let opType = op.["type"].ToObject<string>()
         match opType with
-        | "expect_cell_value" -> renderExpectedCellValueOperation op
+        | "expect_cell_value" -> this.RenderExpectedCellValueOperation op
         | "set_value" -> renderSetValueOperation op
         | "add_callback" -> renderAddCallbackOperation op
         | "remove_callback" -> renderRemoveCallbackOperation op
         | _ -> failwith "Unknown operation type"
 
-    let renderOperations canonicalDataCase = 
-        canonicalDataCase.Input.["operations"]
-        |> Seq.collect renderOperation
-        |> Seq.toList
-
     override __.PropertiesWithIdentifier _ = []
 
     override __.RenderAssert _ = []
 
-    override __.RenderArrange canonicalDataCase =
+    override this.RenderArrange canonicalDataCase =
         let initialVars = renderCells canonicalDataCase
-        let operations = renderOperations canonicalDataCase
+        let operations = this.RenderOperations canonicalDataCase
         initialVars @ operations
 
     override __.AdditionalNamespaces = ["FakeItEasy"]
@@ -1170,9 +1164,7 @@ type RobotSimulator() =
     override this.RenderAssert canonicalDataCase = 
         let renderAssertWithProperty prop =
             let expected = this.RenderExpected (canonicalDataCase, "expected", canonicalDataCase.Expected)
-
-            { Sut = sprintf "sut.%s" prop; Expected = expected }
-            |> renderPartialTemplate "AssertEqual"
+            this.RenderAssertEqual (sprintf "sut.%s" prop) expected
 
         match parseInput canonicalDataCase.Expected with
         | None, Some _ -> [renderAssertWithProperty "position"]

data/tracks/fsharp/generators/Templates.fs

@@ -2,63 +2,34 @@ module Generators.Templates
 
 open System.IO
 open System.Collections.Generic
-open System.Reflection
 open FSharp.Reflection
 open DotLiquid
 open DotLiquid.FileSystems
 open Rendering
 
 type OutputFilter() =
-    static member Format (input: string) = Obj.render input
-
     static member Indent (input: string) = String.indent 1 input
 
-let private fileSystem = LocalFileSystem(Path.GetFullPath("./Templates"))
-Template.RegisterFilter(OutputFilter().GetType())
-Template.FileSystem <- fileSystem :> DotLiquid.FileSystems.IFileSystem
+let private initTemplate() = 
+    Template.FileSystem <- LocalFileSystem(Path.GetFullPath("./Templates"))
+
+    Template.RegisterFilter(OutputFilter().GetType()) |> ignore
 
-let private registrations = Dictionary<_,_>()
-let rec private registerTypeTree templateDataType =
-    if registrations.ContainsKey templateDataType then ()
-    elif FSharpType.IsRecord templateDataType then
-        let properties = templateDataType.GetProperties(BindingFlags.Instance ||| BindingFlags.Public)
-        Template.RegisterSafeType(templateDataType, [| for p in properties -> p.Name |])
-        registrations.[templateDataType] <- true
-        for p in properties do registerTypeTree p.PropertyType
-    elif templateDataType.IsGenericType then
-        let t = templateDataType.GetGenericTypeDefinition()
-        if t = typedefof<seq<_>> || t = typedefof<list<_>> then
-            registrations.[templateDataType] <- true
-            registerTypeTree (templateDataType.GetGenericArguments().[0])
-        elif t = typedefof<IDictionary<_,_>> || t = typedefof<Map<_,_>> then
-            registrations.[templateDataType] <- true
-            registerTypeTree (templateDataType.GetGenericArguments().[0])
-            registerTypeTree (templateDataType.GetGenericArguments().[1])
-        elif t = typedefof<option<_>> then
-            Template.RegisterSafeType(templateDataType, [|"Value"; "IsSome"; "IsNone";|])
-            registrations.[templateDataType] <- true
-            registerTypeTree (templateDataType.GetGenericArguments().[0])
-        elif templateDataType.IsArray then          
-            registrations.[templateDataType] <- true
-            registerTypeTree (templateDataType.GetElementType())
-    else 
-        let properties = templateDataType.GetProperties(BindingFlags.Instance ||| BindingFlags.Public)
-        Template.RegisterSafeType(templateDataType, [| for p in properties -> p.Name |])
-        registrations.[templateDataType] <- true
-        for p in properties do registerTypeTree p.PropertyType
+    Template.RegisterSafeType(typeof<TestMethodBodyAssert>, [| "Sut"; "Expected" |])
+    Template.RegisterSafeType(typeof<TestMethodBody>, [| "Arrange"; "Assert" |])
+    Template.RegisterSafeType(typeof<TestMethod>, [| "Skip"; "Name"; "Body" |])
+    Template.RegisterSafeType(typeof<TestFile>, [| "Version"; "TestModuleName"; "TestedModuleName"; "Namespaces"; "Setup"; "Methods" |])
 
 let private hashFromData (data: obj) =
     match FSharpType.IsRecord (data.GetType()) with
     | true  -> Hash.FromAnonymousObject(data)
     | false -> Hash.FromDictionary(data :?> IDictionary<string, obj>)
 
-let renderInlineTemplate template data =
-    data.GetType() |> registerTypeTree
-
-    let parsedTemplate = Template.Parse template
-    let hash = hashFromData data
-    parsedTemplate.Render(hash)
+let renderTemplate =
+    initTemplate()
 
-let renderPartialTemplate templateName data =
-    let template = sprintf "{%% include \"%s\" %%}" templateName
-    renderInlineTemplate template data
+    fun (name: string) (data: obj) ->
+        let template = sprintf "{%% include \"%s\" %%}" name
+        let parsedTemplate = Template.Parse template
+        let hashedData = hashFromData data
+        parsedTemplate.Render hashedData

data/tracks/haskell/.travis.yml

@@ -34,6 +34,7 @@ install:
 
 script:
  - "sh ./bin/ensure-readmes-are-updated.sh"
+ - "sh ./bin/check-configlet-fmt.sh"
  - |
     differing_stack=""
     expected_stack=$(grep 'RESOLVER.*CURRENT' .travis.yml | head -1 | cut -d'"' -f2)

data/tracks/haskell/bin/check-configlet-fmt.sh

@@ -0,0 +1,42 @@
+#!/bin/sh
+
+# This ensures that config.json and config/maintainers.json are compatible
+# with the output of configlet fmt.
+
+repo=$(cd "$(dirname "$0")/.." && pwd)
+configlet="${repo}/bin/configlet"
+
+if [ ! -x "$configlet" ]; then
+  # Try it from the path.
+  configlet=configlet
+fi
+
+c="${repo}/config.json"
+m="${repo}/config/maintainers.json"
+
+md5() {
+  md5sum $1 | cut -d' ' -f1
+}
+
+# before S sum
+bcs=$(md5 $c)
+bms=$(md5 $m)
+
+cfg=$($configlet fmt .)
+if [ $? != 0 ]; then
+  echo "configlet fmt returned non-0 exit code with output:"
+  echo $cfg
+  exit 1
+fi
+
+# after S sum
+acs=$(md5 $c)
+ams=$(md5 $m)
+
+if [ $bcs != $acs -o $bms != $ams ]; then
+  echo "configlet fmt:"
+  echo $cfg
+  echo "Please update the PR to incorporate those changes."
+  exit 1
+fi
+exit 0