trackler 2.2.1.138 → 2.2.1.139

data/tracks/fsharp/generators/Generators.fsproj

@@ -7,11 +7,12 @@
 
   <ItemGroup>
     <Compile Include="Common.fs" />
+    <Compile Include="Conversion.fs" />
     <Compile Include="Options.fs" />
     <Compile Include="CanonicalData.fs" />
     <Compile Include="Track.fs" />
-    <Compile Include="Formatting.fs" />
     <Compile Include="Rendering.fs" />
+    <Compile Include="Templates.fs" />
     <Compile Include="Exercise.fs" />
     <Compile Include="Generators.fs" />
     <Compile Include="Program.fs" />

data/tracks/fsharp/generators/Rendering.fs

@@ -1,64 +1,172 @@
 module Generators.Rendering
 
-open System.IO
-open System.Collections.Generic
-open System.Reflection
+open System
 open FSharp.Reflection
-open DotLiquid
-open DotLiquid.FileSystems
-open Formatting
-
-type OutputFilter() =
-    static member Format (input: string) = formatValue input
-
-    static member Indent (input: string) = indent 1 input
-
-let private fileSystem = LocalFileSystem(Path.GetFullPath("./Templates"))
-Template.RegisterFilter(OutputFilter().GetType())
-Template.FileSystem <- fileSystem :> DotLiquid.FileSystems.IFileSystem
-
-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
-
-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 renderPartialTemplate templateName data =
-    let template = sprintf "{%% include \"%s\" %%}" templateName
-    renderInlineTemplate template data
+open Newtonsoft.Json.Linq
+open Conversion
+
+module String =
+
+    let private escapeSpecialCharacters(str: string) =
+        str.Replace("\n", "\\n")
+           .Replace("\t", "\\t")
+           .Replace("\r", "\\r")
+           .Replace("\"", "\\\"")
+
+    let render (str: string) =
+        str
+        |> escapeSpecialCharacters
+        |> String.enquote
+
+module Bool =    
+
+    let render b = if b then "true" else "false"
+
+module DateTime =
+
+    let render (dateTime: DateTime) = 
+        if dateTime.TimeOfDay = TimeSpan.Zero then
+            sprintf "DateTime(%d, %d, %d)" dateTime.Year dateTime.Month dateTime.Day
+        else
+            sprintf "DateTime(%d, %d, %d, %d, %d, %d)" dateTime.Year dateTime.Month dateTime.Day dateTime.Hour dateTime.Minute dateTime.Second
+
+    let renderParenthesized (dateTime: DateTime) = 
+        dateTime
+        |> render
+        |> String.parenthesize
+
+module Obj =
+
+    let private renderJToken (jToken: JToken) =
+        match jToken.Type with
+        | JTokenType.Integer  -> jToken.ToObject<int64>()    |> string
+        | JTokenType.Float    -> jToken.ToObject<float>()    |> string
+        | JTokenType.Boolean  -> jToken.ToObject<bool>()     |> Bool.render
+        | JTokenType.String   -> jToken.ToObject<string>()   |> String.render
+        | JTokenType.Date     -> jToken.ToObject<DateTime>() |> DateTime.render
+        | _ -> string jToken
+
+    let private renderTuple tuple = sprintf "%A" tuple
+
+    let private renderRecord record = sprintf "%A" record
+
+    let rec private renderObj (value: obj) =
+        let rec renderJArray (jArray: JArray) =
+            jArray
+            |> Seq.map renderObj
+            |> String.concat "; "
+            |> sprintf "[%s]"
+
+        match value with
+        | :? string as s -> 
+            String.render s
+        | :? bool as b -> 
+            Bool.render b
+        | :? DateTime as dateTime -> 
+            DateTime.render dateTime
+        | :? JArray as jArray -> 
+            renderJArray jArray
+        | :? JToken as jToken -> 
+            renderJToken jToken
+        | _ when FSharpType.IsTuple (value.GetType()) -> 
+            renderTuple value
+        | _ when FSharpType.IsRecord (value.GetType()) -> 
+            renderRecord value
+        | _ -> 
+            string value
+
+    let render value = renderObj value
+
+    let renderEnum typeName value = 
+        let enumType = String.upperCaseFirst typeName
+        let enumValue = String.dehumanize (string value)
+        sprintf "%s.%s" enumType enumValue    
+
+module Option =
+
+    let private renderMap valueMap someMap option =
+        match option with
+        | None -> "None"
+        | Some value -> sprintf "Some %s" (valueMap value) |> someMap
+
+    let renderString option = renderMap id id option
+
+    let renderStringParenthesized option = renderMap id String.parenthesize option
+
+    let render option = renderMap Obj.render id option
+
+    let renderParenthesized option = renderMap Obj.render String.parenthesize option
+
+module Collection =
+    let render formatString collection =
+        collection
+        |> String.concat "; "
+        |> sprintf formatString
+
+    let renderMultiLine openPrefix closePostfix collection =
+        match Seq.length collection with
+        | 0 -> 
+            sprintf "%s%s" openPrefix closePostfix
+        | 1 -> 
+            sprintf "%s%s%s" openPrefix (Seq.head collection) closePostfix
+        | length -> 
+            let lineIndent = String(' ', String.length openPrefix)
+
+            let formatLine i line = 
+                match i with
+                | 0 -> 
+                    sprintf "%s %s;" openPrefix line
+                | _ when i = length - 1 -> 
+                    sprintf "%s %s %s" lineIndent line closePostfix
+                | _ ->
+                    sprintf "%s %s;" lineIndent line
+
+            collection
+            |> Seq.mapi formatLine
+            |> Seq.toList
+            |> List.map (String.indent 2)
+            |> String.concat "\n"
+            |> sprintf "\n%s"
+
+module List =
+
+    let mapRender map value = Collection.render "[%s]" (Seq.map map value)
+
+    let mapRenderMultiLine map value = Collection.renderMultiLine "[" "]" (Seq.map map value)
+
+    let render value = mapRender Obj.render value
+
+    let renderMultiLine value = mapRenderMultiLine Obj.render value
+
+module Array =
+
+    let renderStrings value = Collection.render "[|%s|]" value
+
+    let render value = 
+        value
+        |> Seq.map Obj.render
+        |> renderStrings
+
+module Map =
+
+    let private renderMap<'TKey, 'TValue> map suffix (value: JToken) =
+        let dict = value.ToObject<Collections.Generic.Dictionary<'TKey, 'TValue>>()
+        let formattedList = List.mapRenderMultiLine map dict
+        let whitespace = if Seq.length dict < 2 then " " else sprintf "\n%s" (String.indent 2 "")
+        sprintf "%s%s|> Map.ofList%s" formattedList whitespace suffix
+
+    let mapRender<'TKey, 'TValue> map (value: JToken) =
+        renderMap<'TKey, 'TValue> map "" value
+
+    let render<'TKey, 'TValue> (value: JToken) =
+        mapRender<'TKey, 'TValue> (fun kv -> Obj.render(kv.Key, kv.Value)) value
+
+    let mapRenderOption<'TKey, 'TValue> map (option: JToken option) =
+        match option with 
+        | None -> "None"
+        | Some value ->
+            let suffix = if Seq.length value < 2 then " |> Some" else sprintf "\n%s" (String.indent 2 "|> Some")
+            renderMap<'TKey, 'TValue> map suffix value
+
+    let renderOption<'TKey, 'TValue> (option: JToken option) =
+        mapRenderOption<'TKey, 'TValue> (fun kv -> Obj.render(kv.Key, kv.Value)) option

data/tracks/fsharp/generators/Templates.fs

@@ -0,0 +1,64 @@
+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 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
+
+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 renderPartialTemplate templateName data =
+    let template = sprintf "{%% include \"%s\" %%}" templateName
+    renderInlineTemplate template data

data/tracks/fsharp/generators/Track.fs

@@ -14,12 +14,12 @@ let private convertTrackConfig trackConfigContents = JsonConvert.DeserializeObje
 
 let private trackConfigFile = Path.Combine("..", "config.json")
 
-let private readTrackConfig = File.ReadAllText trackConfigFile
+let private readTrackConfig() = File.ReadAllText trackConfigFile
 
-let private parseTrackConfig = convertTrackConfig readTrackConfig
+let private parseTrackConfig() = convertTrackConfig (readTrackConfig())
 
 let isDeprecated =
-    let config = parseTrackConfig
+    let config = parseTrackConfig()
 
     fun exercise -> 
         config.Exercises

data/tracks/idris/exercises/accumulate/src/Example.idr

@@ -1,6 +1,6 @@
 module Accumulate
 
 export
-accumulate : (Int -> Int) -> List Int -> List Int
+accumulate : (a -> b) -> List a -> List b
 accumulate f [] = []
 accumulate f (x::xs) = f x :: accumulate f xs

data/tracks/idris/exercises/accumulate/src/Test/Accumulate.idr

@@ -8,7 +8,7 @@ assertEq : Eq a => String -> (given : a) -> (expected : a) -> IO ()
 assertEq label g e = putStrLn $ if g == e then label ++ ": Test Passed" else label ++ ": Test Failed"
 
 testEmptyListDoesNothing : IO ()
-testEmptyListDoesNothing = assertEq "empty list does nothing" (accumulate (\x => x) []) []
+testEmptyListDoesNothing = assertEq "empty list does nothing" (accumulate (\x => x) []) (the (List Int) [])
 
 testIdentityFunctionDoesNothing : IO ()
 testIdentityFunctionDoesNothing = assertEq "identity function does nothing" (accumulate (\x => x) [1,2,3]) [1,2,3]
@@ -23,7 +23,7 @@ testIncrementFunctionAddsOneToAllInput : IO ()
 testIncrementFunctionAddsOneToAllInput = assertEq "increment function adds 1 to input" (accumulate (\x => x + 1) [1,2,3]) [2,3,4]
 
 testDecrementFunctionAddsOneToAllInput : IO ()
-testDecrementFunctionAddsOneToAllInput = assertEq "decrement function subtracts 1 from input" (accumulate (\x => x - 1) [1,2,3]) [0,1,2]
+testDecrementFunctionAddsOneToAllInput = assertEq "decrement function subtracts 1 from input" (accumulate (\x => x - 1) [1,2,3]) (the (List Int) [0,1,2])
 
 runTests : IO ()
 runTests = do

data/tracks/java/exercises/rna-transcription/.meta/hints.md

@@ -0,0 +1,2 @@
+For more help on how to solve this exercise, please refer to the tutorial provided as part of the hello world exercise:
+[TUTORIAL.md](https://github.com/exercism/java/blob/master/exercises/hello-world/TUTORIAL.md)

data/tracks/java/exercises/rna-transcription/README.md

@@ -18,6 +18,12 @@ each nucleotide with its complement:
 * `T` -> `A`
 * `A` -> `U`
 
+# Java Tips
+
+For more help on how to solve this exercise, please refer to the tutorial provided as part of the hello world exercise:
+[TUTORIAL.md](https://github.com/exercism/java/blob/master/exercises/hello-world/TUTORIAL.md)
+
+
 # Running the tests
 
 You can run all the tests for an exercise by entering

data/tracks/nim/.gitignore

@@ -3,3 +3,4 @@ nimcache/
 *_test
 bin/configlet
 bin/configlet.exe
+.DS_Store

data/tracks/nim/config.json

@@ -171,6 +171,44 @@
         "bitwise_operations",
         "enumerations"
       ]
+    },
+    {
+      "uuid": "dccdbae7-e882-4171-a517-04562113d059",
+      "slug": "gigasecond",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "dates",
+        "time"
+      ]
+    },
+    {
+      "uuid": "64f70cfe-e34c-43ee-9b9a-72fe54884599",
+      "slug": "space-age",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "mathematics",
+        "floating_point_numbers",
+        "integers",
+        "conditionals"
+      ]
+    },
+    {
+      "uuid": "b1eb9f3c-8724-4b88-a545-2fe34b12b9cf",
+      "slug": "isogram",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "conditionals",
+        "loops",
+        "strings",
+        "algorithms",
+        "maps"
+      ]
     }
   ]
 }

data/tracks/nim/config/maintainers.json

@@ -9,6 +9,16 @@
       "link_text": null,
       "link_url": null,
       "avatar_url": null
+    },
+    {
+      "github_username": "amscotti",
+      "show_on_website": true,
+      "alumnus": false,
+      "name": "Anthony Scotti",
+      "bio": null,
+      "link_text": null,
+      "link_url": "https://128bit.io",
+      "avatar_url": null
     }
   ],
   "docs_url": "https://github.com/exercism/docs/blob/master/maintaining-a-track/maintainer-configuration.md"

data/tracks/nim/docs/ABOUT.md

@@ -0,0 +1,7 @@
+Nim is a general-purpose language designed and developed by Andreas Rumpf and first appearing in 2008. Designed to be efficient, expressive, and elegant. Nim is statically typed and compiled but lets you write elegant code that runs efficiently. Nim lets you target many platforms by compiling code to C, C++, JavaScript, or Objective-C. Nim syntax is similar to Python and shares many of Python's characteristics but draws inspiration from a number of languages, such as C, C++, C#, Lisp, Ada, Go, Oberon, and others.
+
+As Nim is a general-purpose language it can be used in various places but has been filling a real niche in the area of Game development and Systems Programming including Embedded systems.
+
+Nim gives you a lot of the convenience you find in Python and other languages, like easy to read syntax, a package management system for using new libraries in your projects, and user-friendly tracebacks for debugging errors.
+
+Nim gives you the speed and portability of C, but with a high-performance garbage-collector and elegant syntax that makes the language very approachable to new people. Nim also gives you control, letting you change the garbage-collector or turn it off completely giving you the option to manage memory yourself. You have a variety of programming paradigms and abstraction layers with Nim.