trackler 2.2.1.75 → 2.2.1.76

data/tracks/fsharp/generators/Generators.fsproj

@@ -16,10 +16,6 @@
     <Compile Include="Program.fs" />
   </ItemGroup>
 
-  <ItemGroup>
-    <EmbeddedResource Include="Templates\*.liquid" />
-  </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="CommandLineParser" Version="2.1.1-beta" />    
     <PackageReference Include="DotLiquid" Version="2.0.232" />

data/tracks/fsharp/generators/Options.fs

@@ -4,26 +4,60 @@ open System
 open System.IO
 open CommandLine
 
-type Options = {
-  [<Option('e', "exercise", Required = false, 
-    HelpText = "Exercise to generate (if not specified, defaults to all exercises).")>] Exercise : string;
-  [<Option('d', "canonicaldatadirectory", Required = false, 
-    HelpText = "Canonical data directory. If the directory does not exist, the canonical data will be downloaded.")>] CanonicalDataDirectory : string;
-  [<Option('s', "skipupdatecanonicaldata", Required = false,
-    HelpText = "Don't update the canonical data.")>] SkipUpdateCanonicalData : bool;
-}
-
-let private normalizeOptions options =
-    if options.CanonicalDataDirectory <> "" then
-        options 
+type Status = 
+    | Implemented
+    | Unimplemented
+    | MissingData
+    | Custom
+
+type CommandLineOptions = 
+    { [<Option('e', "exercise", Required = false, 
+        HelpText = "Exercise to generate (if not specified, defaults to all exercises).")>] Exercise : string;
+      [<Option('s', "status", Required = false, 
+        HelpText = "The generator status to filter on (defaults to exercises with generator).")>] Status : string;
+      [<Option('d', "canonicaldatadirectory", Required = false, 
+        HelpText = "Canonical data directory. If the directory does not exist, the canonical data will be downloaded.")>] CanonicalDataDirectory : string;
+      [<Option('c', "cachecanonicaldata", Required = false,
+        HelpText = "Use the cached canonical data and don't update the data.")>] CacheCanonicalData : bool; }
+
+type Options =
+    { Exercise : string option
+      Status : Status option
+      CanonicalDataDirectory : string
+      CacheCanonicalData : bool }
+
+let private normalizeCanonicalDataDirectory canonicalDataDirectory = 
+    if canonicalDataDirectory <> "" then
+        canonicalDataDirectory
     else
         let appDataDirectory = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)
         let defaultCanonicalDataDirectory = Path.Combine(appDataDirectory, "exercism", "problem-specifications")
-        { options with CanonicalDataDirectory = defaultCanonicalDataDirectory }
+        defaultCanonicalDataDirectory
+        
+let private normalizeExercise exercise = Option.ofNonEmptyString exercise
+
+let private normalizeStatus status = 
+    match Option.ofNonEmptyString status with
+    | Some "Implemented"   -> Some Implemented
+    | Some "Unimplemented" -> Some Unimplemented
+    | Some "MissingData"   -> Some MissingData
+    | Some "Custom"        -> Some Custom
+    | Some "All"           -> None
+    | Some _               -> failwith "Invalid status" 
+    | None                 -> Some Implemented
+
+let private mapOptions (options: CommandLineOptions) =
+    { Exercise = normalizeExercise options.Exercise
+      Status = normalizeStatus options.Status
+      CanonicalDataDirectory = normalizeCanonicalDataDirectory options.CanonicalDataDirectory
+      CacheCanonicalData = options.CacheCanonicalData }
 
 let parseOptions argv =  
-    let result = CommandLine.Parser.Default.ParseArguments<Options>(argv)
+    let result = CommandLine.Parser.Default.ParseArguments<CommandLineOptions>(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.singleton "Invalid parsing result")
+    | :? Parsed<CommandLineOptions> as parsed -> 
+        Result.Ok(mapOptions parsed.Value)
+    | :? NotParsed<CommandLineOptions> as notParsed -> 
+        Result.Error(notParsed.Errors |> Seq.map string)
+    | _ -> 
+        failwith "Invalid parsing result"

data/tracks/fsharp/generators/Program.fs

@@ -5,21 +5,48 @@ open Exercise
 open CanonicalData
 open Options
 
+let private isNotFilteredByName options (exercise: Exercise) =
+    match options.Exercise with
+    | Some filteredExerciseName -> filteredExerciseName = exerciseName exercise
+    | None -> true
+    
+let private isNotFilteredByStatus options (exercise: Exercise) =
+    match options.Status, exercise with
+    | None, _ -> true
+    | Some Status.Implemented,   Exercise.Generator _     -> true
+    | Some Status.Unimplemented, Exercise.Unimplemented _ -> true
+    | Some Status.MissingData,   Exercise.MissingData _   -> true
+    | Some Status.Custom,        Exercise.Custom _        -> true
+    | _ -> false
+
+let private shouldBeIncluded options (exercise: Exercise) =
+    isNotFilteredByName options exercise &&
+    isNotFilteredByStatus options exercise
+
 let private regenerateTestClass options =
     let parseCanonicalData' = parseCanonicalData options
 
-    fun (exercise: Exercise) ->
-        let canonicalData = parseCanonicalData' exercise.Name
-        exercise.Regenerate(canonicalData)
+    fun (exercise) ->
+        match exercise with
+        | Exercise.Custom custom ->
+            Log.Information("{Exercise}: has customized tests", custom.Name)
+        | Exercise.Unimplemented unimplemented ->
+            Log.Error("{Exercise}: missing test generator", unimplemented.Name)
+        | Exercise.MissingData missingData ->
+            Log.Warning("{Exercise}: missing canonical data", missingData.Name)
+        | Exercise.Generator generator ->
+            let canonicalData = parseCanonicalData' generator.Name
+            generator.Regenerate(canonicalData)
+            Log.Information("{Exercise}: tests generated", generator.Name)
 
 let private regenerateTestClasses options =
     Log.Information("Re-generating test classes...")
 
     let regenerateTestClass' = regenerateTestClass options
-    let filteredExercise = Option.ofNonEmptyString options.Exercise
-
-    createExercises filteredExercise
-    |> Seq.iter regenerateTestClass'
+    
+    createExercises options
+    |> List.filter (shouldBeIncluded options)
+    |> List.iter regenerateTestClass'
 
     Log.Information("Re-generated test classes.")
 

data/tracks/fsharp/generators/Rendering.fs

@@ -1,5 +1,6 @@
 module Generators.Rendering
 
+open System.IO
 open System.Collections.Generic
 open System.Reflection
 open FSharp.Reflection
@@ -12,7 +13,7 @@ type OutputFilter() =
 
     static member Indent (input: string) = indent 1 input
 
-let private fileSystem = EmbeddedFileSystem(Assembly.GetExecutingAssembly(), "Generators.Templates")
+let private fileSystem = LocalFileSystem(Path.GetFullPath("./Templates"))
 Template.RegisterFilter(OutputFilter().GetType())
 Template.FileSystem <- fileSystem :> DotLiquid.FileSystems.IFileSystem
 

data/tracks/go/config.json

@@ -115,6 +115,17 @@
       "unlocked_by": null,
       "uuid": "c2064df8-cce5-4f03-9d85-0818b4e34112"
     },
+    {
+      "core": false,
+      "difficulty": 2,
+      "slug": "reverse-string",
+      "topics": [
+        "sequences",
+        "strings"
+      ],
+      "unlocked_by": "isogram",
+      "uuid": "e2df2756-7a48-4b45-b601-91be91027dbd"
+    },
     {
       "core": true,
       "difficulty": 2,

data/tracks/go/exercises/reverse-string/.meta/gen.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"log"
+	"text/template"
+
+	"../../../gen"
+)
+
+func main() {
+	t, err := template.New("").Parse(tmpl)
+	if err != nil {
+		log.Fatal(err)
+	}
+	var j js
+	if err := gen.Gen("reverse-string", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Exercise string
+	Version  string
+	Cases    []oneCase
+}
+
+// Test cases
+type oneCase struct {
+	Description string
+	Property    string
+	Input       string
+	Expected    string
+}
+
+// Template to generate test cases.
+var tmpl = `package reverse
+
+{{.Header}}
+
+var testCases = []struct {
+	description	string
+	input		string
+	expected	string
+}{ {{range .J.Cases}}
+{
+	description:	{{printf "%q"  .Description}},
+	input:		{{printf "%q"  .Input}},
+	expected:	{{printf "%q"  .Expected}},
+},{{end}}
+}
+`

data/tracks/go/exercises/reverse-string/README.md

@@ -0,0 +1,31 @@
+# reverse-string
+
+Reverse a string
+
+For example:
+input: "cool"
+output: "looc"
+
+## Running the tests
+
+To run the tests run the command `go test` from within the exercise directory.
+
+If the test suite contains benchmarks, you can run these with the `-bench`
+flag:
+
+    go test -bench .
+
+Keep in mind that each reviewer will run benchmarks on a different machine, with
+different specs, so the results from these benchmark tests may vary.
+
+## Further information
+
+For more detailed information about the Go track, including how to get help if
+you're having trouble, please visit the exercism.io [Go language page](http://exercism.io/languages/go/about).
+
+## Source
+
+Introductory challenge to reverse an input string [https://medium.freecodecamp.org/how-to-reverse-a-string-in-javascript-in-3-different-ways-75e4763c68cb](https://medium.freecodecamp.org/how-to-reverse-a-string-in-javascript-in-3-different-ways-75e4763c68cb)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/go/exercises/reverse-string/cases_test.go

@@ -0,0 +1,37 @@
+package reverse
+
+// Source: exercism/problem-specifications
+// Commit: ae82c90 More consistent reverse-string canonical data
+// Problem Specifications Version: 1.0.1
+
+var testCases = []struct {
+	description string
+	input       string
+	expected    string
+}{
+	{
+		description: "an empty string",
+		input:       "",
+		expected:    "",
+	},
+	{
+		description: "a word",
+		input:       "robot",
+		expected:    "tobor",
+	},
+	{
+		description: "a capitalized word",
+		input:       "Ramen",
+		expected:    "nemaR",
+	},
+	{
+		description: "a sentence with punctuation",
+		input:       "I'm hungry!",
+		expected:    "!yrgnuh m'I",
+	},
+	{
+		description: "a palindrome",
+		input:       "racecar",
+		expected:    "racecar",
+	},
+}

data/tracks/go/exercises/reverse-string/example.go

@@ -0,0 +1,10 @@
+package reverse
+
+// String reverses given string
+func String(s string) string {
+	runes := []rune(s)
+	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
+		runes[i], runes[j] = runes[j], runes[i]
+	}
+	return string(runes)
+}

data/tracks/go/exercises/reverse-string/reverse_string_test.go

@@ -0,0 +1,25 @@
+package reverse
+
+import (
+	"testing"
+	"testing/quick"
+)
+
+func TestReverse(t *testing.T) {
+	for _, testCase := range testCases {
+		if res := String(testCase.input); res != testCase.expected {
+			t.Fatalf("FAIL: %s(%s)\nExpected: %q\nActual: %q",
+				testCase.description, testCase.input, testCase.expected, res)
+		}
+		t.Logf("PASS: %s", testCase.description)
+	}
+}
+
+func TestReverseOfReverse(t *testing.T) {
+	assertion := func(s string) bool {
+		return s == String(String(s))
+	}
+	if err := quick.Check(assertion, nil); err != nil {
+		t.Fatal(err)
+	}
+}

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

@@ -6,6 +6,8 @@ Bob answers 'Sure.' if you ask him a question.
 
 He answers 'Whoa, chill out!' if you yell at him.
 
+He answers 'Calm down, I know what I'm doing!' if you yell a question at him.
+
 He says 'Fine. Be that way!' if you address him without actually saying
 anything.
 

data/tracks/haskell/exercises/bob/examples/success-standard/src/Bob.hs

@@ -1,16 +1,20 @@
 module Bob (responseFor) where
 import Data.Char (isSpace, isUpper, isAlpha)
 
-data Prompt = Silence | Yell | Question | Other
+data Prompt = Silence | YellQuestion | Yell | Question | Other
 
 classify :: String -> Prompt
 classify s | all isSpace s = Silence
-           | any isAlpha s && all isUpper (filter isAlpha s) = Yell
-           | '?' == last (filter (not . isSpace) s) = Question
+           | yell && question = YellQuestion
+           | yell = Yell
+           | question = Question
            | otherwise = Other
+           where yell = any isAlpha s && all isUpper (filter isAlpha s)
+                 question = '?' == last (filter (not . isSpace) s)
 
 response :: Prompt -> String
 response Silence = "Fine. Be that way!"
+response YellQuestion = "Calm down, I know what I'm doing!"
 response Yell = "Whoa, chill out!"
 response Question = "Sure."
 response Other = "Whatever."

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

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

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

@@ -54,7 +54,7 @@ cases = [ Case { description = "stating something"
                }
         , Case { description = "forceful question"
                , input       = "WHAT THE HELL WERE YOU THINKING?"
-               , expected    = "Whoa, chill out!"
+               , expected    = "Calm down, I know what I'm doing!"
                }
         , Case { description = "shouting numbers"
                , input       = "1, 2, 3 GO!"

data/tracks/haskell/exercises/isbn-verifier/README.md

@@ -1,40 +1,45 @@
 # Isbn Verifier
 
-Check if a given ISBN-10 is valid.
+The [ISBN-10 verification process](https://en.wikipedia.org/wiki/International_Standard_Book_Number) is used to validate book identification
+numbers. These normally contain dashes and look like: `3-598-21508-8`
 
-## Functionality
+## ISBN
 
-Given an unknown string the program should check if the provided string is a valid ISBN-10.
-Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+The ISBN-10 format is 9 digits (0 to 9) plus one check character (either a digit or an X only). In the case the check character is an X, this represents the value '10'. These may be communicated with or without hyphens, and can be checked for their validity by the following formula:
 
-The program should allow for ISBN-10 without the separating dashes to be verified as well.
+```
+(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0
+```
 
-## ISBN
+If the result is 0, then it is a valid ISBN-10, otherwise it is invalid.
 
-Let's take a random ISBN-10 number, say `3-598-21508-8` for this.
-The first digit block indicates the group where the ISBN belongs. Groups can consist of shared languages, geographic regions or countries. The leading '3' signals this ISBN is from a german speaking country.
-The following number block is to identify the publisher. Since this is a three digit publisher number there is a 5 digit title number for this book.
-The last digit in the ISBN is the check digit which is used to detect read errors.
+## Example
 
-The first 9 digits in the ISBN have to be between 0 and 9.
-The check digit can additionally be an 'X' to allow 10 to be a valid check digit as well.
+Let's take the ISBN-10 `3-598-21508-8`. We plug it in to the formula, and get:
+```
+(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 == 0
+```
+
+Since the result is 0, this proves that our ISBN is valid.
+
+## Task
+
+Given a string the program should check if the provided string is a valid ISBN-10.
+Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
 
-A valid ISBN-10 is calculated with this formula `(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0`
-So for our example ISBN this means:
-(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 = 0
+The program should be able to verify ISBN-10 both with and without separating dashes.
 
-Which proves that the ISBN is valid.
 
 ## Caveats
 
-Converting from string to number can be tricky in certain languages.
-It's getting even trickier since the check-digit of an ISBN-10 can be 'X'.
+Converting from strings to numbers can be tricky in certain languages.
+Now, it's even trickier since the check digit of an ISBN-10 may be 'X' (representing '10'). For instance `3-598-21507-X` is a valid ISBN-10.
 
 ## Bonus tasks
 
-* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier)
+* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier).
 
-* Generate valid ISBN, maybe even from a given starting ISBN
+* Generate valid ISBN, maybe even from a given starting ISBN.
 
 ## Getting Started