trackler 2.2.1.44 → 2.2.1.45

data/tracks/fsharp/generators/Generators.sln

@@ -0,0 +1,24 @@
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26730.12
+MinimumVisualStudioVersion = 15.0.26124.0
+Project("{6EC3EE1D-3C4E-46DD-8F32-0CC8E7565705}") = "Generators", "Generators.fsproj", "{083C3030-8EC9-4EB7-BBD2-989BD4CE28FE}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{083C3030-8EC9-4EB7-BBD2-989BD4CE28FE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{083C3030-8EC9-4EB7-BBD2-989BD4CE28FE}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{083C3030-8EC9-4EB7-BBD2-989BD4CE28FE}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{083C3030-8EC9-4EB7-BBD2-989BD4CE28FE}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {57678E76-BB77-4CB6-AD28-77C5DC345BDE}
+	EndGlobalSection
+EndGlobal

data/tracks/fsharp/generators/Input.fs

@@ -0,0 +1,99 @@
+module Generators.Input
+
+open System
+open System.IO
+open System.Collections.Generic
+open Serilog
+open LibGit2Sharp
+open Newtonsoft.Json
+open Newtonsoft.Json.Linq
+open Newtonsoft.Json.Serialization
+open Humanizer
+open Options
+
+let [<Literal>] private ProblemSpecificationsGitUrl = "https://github.com/exercism/problem-specifications.git";
+let [<Literal>] private ProblemSpecificationsBranch = "master";
+let [<Literal>] private ProblemSpecificationsRemote = "origin";
+let [<Literal>] private ProblemSpecificationsRemoteBranch = ProblemSpecificationsRemote + "/" + ProblemSpecificationsBranch;
+
+let private cloneRepository options =
+    if (Directory.Exists(options.CanonicalDataDirectory)) then
+        ()
+    else
+        Log.Information("Cloning repository...")
+
+        Repository.Clone(ProblemSpecificationsGitUrl, options.CanonicalDataDirectory) |> ignore
+
+        Log.Information("Repository cloned.")
+
+let private updateToLatestVersion options =
+    Log.Information("Updating repository to latest version...");
+
+    use repository = new Repository(options.CanonicalDataDirectory)
+    
+    Commands.Fetch(repository, ProblemSpecificationsRemote, Seq.empty, FetchOptions(), null)
+    
+    let remoteBranch = repository.Branches.[ProblemSpecificationsRemoteBranch];
+    repository.Reset(ResetMode.Hard, remoteBranch.Tip);
+
+    Log.Information("Updated repository to latest version.");
+
+let private downloadData options =
+    if options.SkipUpdateCanonicalData then
+        ()
+    else
+        cloneRepository options
+        updateToLatestVersion options    
+
+let private readCanonicalData options exercise = 
+    let exerciseCanonicalDataPath = Path.Combine(options.CanonicalDataDirectory, "exercises", exercise, "canonical-data.json")
+    File.ReadAllText(exerciseCanonicalDataPath)
+
+let jsonSerializerSettings = JsonSerializerSettings()
+let jsonSerializer = JsonSerializer()
+
+type CanonicalDataConverter() =
+    inherit JsonConverter()
+
+    let createCanonicalDataCasePropertiesFromJToken (jToken: JToken) =
+        jToken.ToObject<IDictionary<string, obj>>()
+        |> Dict.toMap
+
+    let createDescriptionPathFromJToken (jToken: JToken): string list =
+        let descriptionFromJToken (currentToken: JToken) =
+            match currentToken.SelectToken("description") with
+            | null ->  None
+            | description -> Some (description.ToObject<string>())
+
+        jToken
+        |> Json.parentsAndSelf
+        |> List.choose descriptionFromJToken
+
+    let createCanonicalDataCaseFromJToken (jToken: JToken) =
+        { Properties = createCanonicalDataCasePropertiesFromJToken jToken
+          DescriptionPath = createDescriptionPathFromJToken jToken }
+
+    let createCanonicalDataCasesFromJToken (jToken: JToken) =  
+        jToken.["cases"].SelectTokens("$..*[?(@.property)]")
+        |> Seq.map createCanonicalDataCaseFromJToken
+        |> Seq.toList
+
+    let createCanonicalDataFromJToken (jToken: JToken) =
+        { Exercise = jToken.["exercise"].Value<string>()
+          Version = jToken.["version"].Value<string>()
+          Cases = createCanonicalDataCasesFromJToken jToken }
+
+    override this.WriteJson(writer: JsonWriter, value: obj, serializer: JsonSerializer) = failwith "Not supported"
+
+    override this.ReadJson(reader: JsonReader, objectType: Type, existingValue: obj, serializer: JsonSerializer) =
+        let jToken = JToken.ReadFrom(reader)
+        createCanonicalDataFromJToken jToken :> obj
+
+    override this.CanConvert(objectType: Type) = objectType = typeof<CanonicalData>
+
+let convertCanonicalData canonicalDataContents = 
+    JsonConvert.DeserializeObject<CanonicalData>(canonicalDataContents, CanonicalDataConverter()) 
+
+let parseCanonicalData options = 
+    downloadData options 
+    readCanonicalData options >> convertCanonicalData

data/tracks/fsharp/generators/Options.fs

@@ -0,0 +1,31 @@
+module Generators.Options
+
+open System
+open System.IO
+open CommandLine
+open Serilog
+open Humanizer
+
+type Options = {
+  [<CommandLine.Option('e', "exercises", Required = false, 
+    HelpText = "Exercises to generate (if not specified, defaults to all exercises).")>] Exercises : seq<string>;
+  [<CommandLine.Option('d', "canonicaldatadirectory", Required = false, 
+    HelpText = "Canonical data directory. If the directory does not exist, the canonical data will be downloaded.")>] CanonicalDataDirectory : string;
+  [<CommandLine.Option('s', "skipupdatecanonicaldata", Required = false,
+    HelpText = "Don't update the canonical data.")>] SkipUpdateCanonicalData : bool;
+}
+
+let private normalizeOptions options =
+    if options.CanonicalDataDirectory <> "" then
+        options 
+    else
+        let appDataDirectory = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)
+        let defaultCanonicalDataDirectory = Path.Combine(appDataDirectory, "exercism", "problem-specifications")
+        { options with CanonicalDataDirectory = defaultCanonicalDataDirectory }
+
+let parseOptions argv =  
+    let result = CommandLine.Parser.Default.ParseArguments<Options>(argv)
+    match result with
+    | :? Parsed<Options> as parsed -> Result.Ok(normalizeOptions parsed.Value)
+    | :? NotParsed<Options> as notParsed -> Result.Error(notParsed.Errors |> Seq.map string)
+    | _ -> Result.Error(seq { yield "Invalid parsing result" })

data/tracks/fsharp/generators/Output.fs

@@ -0,0 +1,224 @@
+module Generators.Output
+
+open System
+open System.Collections.Generic
+open System.IO
+open System.Reflection
+open FSharp.Reflection
+open DotLiquid
+open DotLiquid.FileSystems
+open Newtonsoft.Json.Linq
+open Input
+
+let indent level value = 
+    let indentation = String.replicate level "    "
+    sprintf "%s%s" indentation value
+
+let parenthesize value = sprintf "(%s)" value
+
+let backwardPipe value = sprintf "<| %s" value
+
+let backwardPipeConditional test value = if test value then backwardPipe value else value
+
+let addTypeAnnotation typeAnnotation value = sprintf "%s: %s" value typeAnnotation
+
+let escapeSpecialCharacters (str: string) =
+    str.Replace("\n", "\\n")
+       .Replace("\t", "\\t")
+       .Replace("\r", "\\r")
+       .Replace("\"", "\\\"")
+
+let formatString str = 
+    str
+    |> escapeSpecialCharacters
+    |> sprintf "\"%s\""
+
+let formatBool b = if b then "true" else "false"
+
+let formatDateTime (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 formatTimeSpan (timeSpan: TimeSpan) = 
+    sprintf "TimeSpan(%d, %d, %d)" timeSpan.Hours timeSpan.Minutes timeSpan.Seconds
+
+let normalizeJArray (jArray: JArray): obj list =
+    let toBoxedList seq = 
+        seq
+        |> Seq.map box 
+        |> List.ofSeq
+
+    if jArray.Count = 0 then
+        []
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Integer) then
+        jArray.Values<int>() |> toBoxedList
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Float) then
+        jArray.Values<float>() |> toBoxedList
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Boolean) then
+        jArray.Values<bool>() |> toBoxedList
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.String) then
+        jArray.Values<string>() |> toBoxedList
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Date) then
+        jArray.Values<DateTime>() |> toBoxedList
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.TimeSpan) then
+        jArray.Values<TimeSpan>() |> toBoxedList
+    else if jArray.Children() |> Seq.forall (fun x -> x.Type = JTokenType.Object) then
+        jArray.Children() |> Seq.map (fun jObject -> jObject.ToObject<Dictionary<string, obj>>()) |> toBoxedList
+    else    
+        jArray.Values<obj>() |> toBoxedList
+
+let formatToken (jToken: JToken) =
+    match jToken.Type with
+    | JTokenType.Integer  -> jToken.ToObject<int>()      |> string
+    | JTokenType.Float    -> jToken.ToObject<float>()    |> string
+    | JTokenType.Boolean  -> jToken.ToObject<bool>()     |> formatBool
+    | JTokenType.String   -> jToken.ToObject<string>()   |> formatString
+    | JTokenType.Date     -> jToken.ToObject<DateTime>() |> formatDateTime
+    | JTokenType.TimeSpan -> jToken.ToObject<TimeSpan>() |> formatTimeSpan
+    | _ -> string jToken
+
+let formatJArray (jArray: JArray) =
+    jArray
+    |> normalizeJArray
+    |> sprintf "%A"
+
+let formatTuple tuple = sprintf "%A" tuple
+
+let formatRecord record = sprintf "%A" record
+
+let formatOption option = 
+    match option with
+    | None -> "None"
+    | Some x -> sprintf "Some %s" x
+
+let formatResult result = 
+    match result with
+    | Ok x -> sprintf "Ok %s" x
+    | Error y -> sprintf "Error %s" y
+
+let rec formatValue (value: obj) =
+    match value with
+    | :? string as s -> 
+        formatString s
+    | :? bool as b -> 
+        formatBool b
+    | :? DateTime as dateTime -> 
+        formatDateTime dateTime
+    | :? JArray as jArray -> 
+        formatJArray jArray
+    | :? JToken as jToken -> 
+        formatToken jToken
+    | :? Option<obj> as option -> 
+        option |> Option.map formatValue |> formatOption
+    | :? Result<obj, obj> as result -> 
+        result |> Result.map formatValue |> Result.mapError formatValue |> formatResult
+    | _ when FSharpType.IsTuple (value.GetType()) -> 
+        formatTuple value
+    | _ when FSharpType.IsRecord (value.GetType()) -> 
+        formatRecord value
+    | _ -> 
+        string value
+
+let formatCollection formatString collection =
+    collection
+    |> String.concat "; "
+    |> sprintf formatString
+
+let formatList sequence = formatCollection "[%s]" sequence
+
+let formatArray sequence = formatCollection "[|%s|]" sequence
+
+let formatSequence sequence = formatCollection "seq {%s}" sequence
+
+let formatMultiLineCollection (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 (indent 2)
+        |> String.concat "\n"
+        |> sprintf "\n%s"
+
+let formatMultiLineList sequence = formatMultiLineCollection ("[", "]") sequence
+
+let formatMultiLineArray sequence = formatMultiLineCollection ("[|", "|]") sequence
+
+let formatMultiLineSequence sequence = formatMultiLineCollection ("seq {", "}") sequence
+
+let formatMultiLineString strings = 
+    let length = Seq.length strings
+    let formatLine i line =
+        match i = length - 1 with
+        | true  -> line
+        | false -> sprintf "%s +" line
+
+    strings
+    |> Seq.mapi formatLine
+    |> Seq.toList      
+
+type OutputFilter() =
+    static member Format (input: string) = formatValue input
+
+    static member Indent (input: string) = indent 1 input
+
+let private fileSystem = EmbeddedFileSystem(Assembly.GetExecutingAssembly(), "")
+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 renderInlineTemplate template data =
+    data.GetType() |> registerTypeTree
+
+    let parsedTemplate = Template.Parse template
+    parsedTemplate.Render(Hash.FromAnonymousObject(data))
+
+let renderPartialTemplate templateName data =
+    let template = sprintf "{%% include \"%s\" %%}" templateName
+    renderInlineTemplate template data

data/tracks/fsharp/generators/Program.fs

@@ -0,0 +1,35 @@
+module Generators.Program
+
+open Serilog
+open Exercise
+open Input
+open Options
+
+let regenerateTestClass options =
+    let parseCanonicalData' = parseCanonicalData options
+
+    fun (exercise: Exercise) ->
+        let canonicalData = parseCanonicalData' exercise.Name
+        exercise.Regenerate(canonicalData)
+
+let regenerateTestClasses options =
+    Log.Information("Re-generating test classes...")
+
+    let regenerateTestClass' = regenerateTestClass options
+
+    createExercises options.Exercises
+    |> Seq.iter regenerateTestClass'
+
+    Log.Information("Re-generated test classes.")
+
+[<EntryPoint>]
+let main argv = 
+    Logging.setupLogger()
+
+    match parseOptions argv with
+    | Result.Ok(options) -> 
+        regenerateTestClasses options
+        0
+    | Result.Error(errors) -> 
+        Log.Error("Error(s) parsing commandline arguments: {Errors}", errors)
+        1

data/tracks/fsharp/generators/Properties/launchSettings.json

@@ -0,0 +1,8 @@
+{
+  "profiles": {
+    "Generators": {
+      "commandName": "Project",
+      "commandLineArgs": "-e allergies"
+    }
+  }
+}

data/tracks/fsharp/generators/Templates/_AssertEmpty.liquid

@@ -0,0 +1 @@
+{{ Sut }} |> should be Empty

data/tracks/fsharp/generators/Templates/_AssertEqual.liquid

@@ -0,0 +1 @@
+{{ Sut }} |> should equal {{ Expected }}

data/tracks/fsharp/generators/Templates/_TestClass.liquid

@@ -0,0 +1,13 @@
+// This file was auto-generated based on version {{ Version }} of the canonical data.
+
+module {{ TestModuleName }}
+
+{%- for namespace in Namespaces -%}
+open {{ namespace }}
+{%- endfor -%}
+
+open {{ TestedModuleName }}
+
+{%- for method in Methods -%}
+{{ method }}
+{%- endfor -%}

data/tracks/fsharp/generators/Templates/_TestMethod.liquid

@@ -0,0 +1,3 @@
+[<Fact{% if Skip %}(Skip = "Remove to run test"){% endif %}>]
+let ``{{ Name }}`` () =
+{{ Body }}

data/tracks/fsharp/generators/Templates/_TestMethodBody.liquid

@@ -0,0 +1,4 @@
+{%- for arrange in Arrange -%}
+{{ arrange | indent }}
+{%- endfor -%}
+{{ Assert | indent }}

data/tracks/go/.travis.yml

@@ -18,8 +18,8 @@ sudo: false
 # but since Travis only runs five jobs at a time throughout all of Exercism,
 # it is better citizenship to not test the additional versions.
 go:
-  - 1.8.3
-  - 1.9
+  - 1.8.x
+  - 1.x
   - tip
 
 # Travis runs in a 64 bit environment but beginning with Go 1.5, building a
@@ -61,7 +61,7 @@ script:
 matrix:
   include:
     # Keep this in sync with the latest version.
-    - go: 1.8
+    - go: 1.x
       env: STATIC_CHECKERS=1
   allow_failures:
     - go: tip

data/tracks/groovy/CONTRIBUTING.md

@@ -13,7 +13,7 @@ This guide might be helpful before you start implementing the exercise: [Porting
 It's expected that your code follows the official Style guide: http://groovy-lang.org/style-guide.html
 
 ### Testing
-Instead of using JUnit we prefer [Spok](https://github.com/spockframework/spock) ~for consistency~ because it's an awesome framework!
+Instead of using JUnit we prefer [Spock](https://github.com/spockframework/spock) ~for consistency~ because it's an awesome framework!
 
 ## Pull Requests
-It would be awesome if you follow this [simple guidelines](https://github.com/exercism/docs/blob/master/contributing/pull-request-guidelines.md) while creating your PR, but it isn't required.
+It would be awesome if you follow this [simple guidelines](https://github.com/exercism/docs/blob/master/contributing/pull-request-guidelines.md) while creating your PR, but it isn't required.

data/tracks/groovy/config.json

@@ -2,6 +2,7 @@
   "language": "Groovy",
   "checklist_issue": 9,
   "active": false,
+  "blurb": "Groovy is an unopinionated, multi-paradigm language that enhances Java with the intent to make your code less verbose, yet still allows you utilize the power of the JVM.",
   "test_pattern": "(Spec)[.]groovy",
   "foregone": [
 
@@ -152,6 +153,17 @@
         "string manipulation",
         "regular expressions"
       ]
+    },
+    {
+      "uuid": "1d098fb3-0a27-5380-3849-73f2ca77ff2f84ca698",
+      "slug": "scrabble-score",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+        "strings",
+        "mathematics"
+      ]
     }
   ]
 }

data/tracks/groovy/exercises/scrabble-score/Example.groovy

@@ -0,0 +1,18 @@
+class ScrabbleScore {
+
+    static final letterValues = [
+        'D': 2, 'G': 2,
+        'B': 3, 'C': 3, 'M': 3, 'P': 3,
+        'F': 4, 'H': 4, 'V': 4, 'W': 4, 'Y': 4,
+        'K': 5,
+        'J': 8, 'X': 8,
+        'Q': 10, 'Z': 10
+    ].withDefault { 1 }
+
+    static scoreWord(String word) {
+        word.toUpperCase().inject(0) { total, letter ->
+            total + letterValues[letter]
+        }
+    }
+
+}

data/tracks/groovy/exercises/scrabble-score/README.md

@@ -0,0 +1,63 @@
+## Scrabble Score
+
+Given a word, compute the scrabble score for that word.
+
+## Letter Values
+
+You'll need these:
+
+```text
+Letter                           Value
+A, E, I, O, U, L, N, R, S, T       1
+D, G                               2
+B, C, M, P                         3
+F, H, V, W, Y                      4
+K                                  5
+J, X                               8
+Q, Z                               10
+```
+
+## Examples
+
+"cabbage" should be scored as worth 14 points:
+
+- 3 points for C
+- 1 point for A, twice
+- 3 points for B, twice
+- 2 points for G
+- 1 point for E
+
+And to total:
+
+- `3 + 2*1 + 2*3 + 2 + 1`
+- = `3 + 2 + 6 + 3`
+- = `5 + 9`
+- = 14
+
+## Extensions
+
+- You can play a double or a triple letter.
+- You can play a double or a triple word.
+
+## Source
+
+Inspired by the Extreme Startup game. [https://github.com/rchatley/extreme_startup](https://github.com/rchatley/extreme_startup)
+
+## Need help?
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/groovy).
+
+## Running the Tests
+Run the tests by executing the test script.
+
+```
+$ groovy ./ScrabbleScoreSpec.groovy
+```
+
+After the first test(s) pass, continue by commenting out or removing the `@Ignore` annotations on other tests.
+
+When all tests pass, congratulations!
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/groovy/exercises/scrabble-score/ScrabbleScore.groovy

@@ -0,0 +1,7 @@
+class ScrabbleScore {
+
+    static scoreWord(String word) {
+        throw new UnsupportedOperationException('scoreWord method not implemented.')
+    }
+
+}

data/tracks/groovy/exercises/scrabble-score/ScrabbleScoreSpec.groovy

@@ -0,0 +1,45 @@
+@Grab('org.spockframework:spock-core:1.0-groovy-2.4')
+import spock.lang.*
+
+class ScrabbleScoreSpec extends Specification {
+
+    def 'lowercase letter'() {
+        expect:
+        ScrabbleScore.scoreWord('a') == 1
+    }
+
+    def 'uppercase letter'() {
+        expect:
+        ScrabbleScore.scoreWord('A') == 1
+    }
+
+    def 'valuable letter'() {
+        expect:
+        ScrabbleScore.scoreWord('f') == 4
+    }
+
+    def 'empty input'() {
+        expect:
+        ScrabbleScore.scoreWord('') == 0
+    }
+
+    @Unroll
+    def 'score for word #word should be #expectedScore'() {
+        when:
+        def score = ScrabbleScore.scoreWord(word)
+
+        then:
+        score == expectedScore
+
+        where:
+        word                         | expectedScore
+        'at'                         | 2
+        'zoo'                        | 12
+        'street'                     | 6
+        'quirky'                     | 22
+        'OxyphenButazone'            | 41
+        'pinata'                     | 8
+        'abcdefghijklmnopqrstuvwxyz' | 87
+    }
+
+}

data/tracks/groovy/exercises/two-fer/TwoFer.groovy

@@ -1,6 +1,6 @@
 class TwoFer {
 
     static String twoFer(String name) {
-        throw UnsupportedOperionExcetion('Method is not implemented')
+        throw new UnsupportedOperationException('Method is not implemented')
     }
-}
+}

data/tracks/haskell/exercises/change/README.md

@@ -71,7 +71,7 @@ one, head over there and create an issue.  We'll do our best to help you!
 
 ## Source
 
-Software Craftsmanship - Kata-logue [http://craftsmanship.sv.cmu.edu/exercises/coin-change-kata](http://craftsmanship.sv.cmu.edu/exercises/coin-change-kata)
+Software Craftsmanship - Coin Change Kata [https://web.archive.org/web/20130115115225/http://craftsmanship.sv.cmu.edu:80/exercises/coin-change-kata](https://web.archive.org/web/20130115115225/http://craftsmanship.sv.cmu.edu:80/exercises/coin-change-kata)
 
 ## Submitting Incomplete Solutions
 It's possible to submit an incomplete solution so you can see how others have completed the exercise.