trackler 2.2.1.74 → 2.2.1.75

data/tracks/fsharp/generators/Generators.fsproj

@@ -8,8 +8,9 @@
   <ItemGroup>
     <Compile Include="Common.fs" />
     <Compile Include="Options.fs" />
-    <Compile Include="Input.fs" />
-    <Compile Include="Output.fs" />
+    <Compile Include="CanonicalData.fs" />
+    <Compile Include="Formatting.fs" />
+    <Compile Include="Rendering.fs" />
     <Compile Include="Exercise.fs" />
     <Compile Include="Generators.fs" />
     <Compile Include="Program.fs" />
@@ -21,12 +22,16 @@
 
   <ItemGroup>
     <PackageReference Include="CommandLineParser" Version="2.1.1-beta" />    
-    <PackageReference Include="DotLiquid" Version="2.0.200" />
+    <PackageReference Include="DotLiquid" Version="2.0.232" />
     <PackageReference Include="Humanizer" Version="2.2.0" />
     <PackageReference Include="LibGit2Sharp.Portable" Version="0.24.10" />
     <PackageReference Include="Newtonsoft.Json" Version="10.0.3" />
-    <PackageReference Include="serilog" Version="2.5.0" />
+    <PackageReference Include="serilog" Version="2.6.0" />
     <PackageReference Include="serilog.sinks.literate" Version="3.0.0" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Update="FSharp.Core" Version="4.2.3" />
+  </ItemGroup>
+
 </Project>

data/tracks/fsharp/generators/Options.fs

@@ -26,4 +26,4 @@ let parseOptions 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" })
+    | _ -> Result.Error(Seq.singleton "Invalid parsing result")

data/tracks/fsharp/generators/Program.fs

@@ -2,17 +2,17 @@
 
 open Serilog
 open Exercise
-open Input
+open CanonicalData
 open Options
 
-let regenerateTestClass options =
+let private regenerateTestClass options =
     let parseCanonicalData' = parseCanonicalData options
 
     fun (exercise: Exercise) ->
         let canonicalData = parseCanonicalData' exercise.Name
         exercise.Regenerate(canonicalData)
 
-let regenerateTestClasses options =
+let private regenerateTestClasses options =
     Log.Information("Re-generating test classes...")
 
     let regenerateTestClass' = regenerateTestClass options

data/tracks/fsharp/generators/Rendering.fs

@@ -0,0 +1,57 @@
+module Generators.Rendering
+
+open System.Collections.Generic
+open System.Reflection
+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 = EmbeddedFileSystem(Assembly.GetExecutingAssembly(), "Generators.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 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/go/exercises/all-your-base/.meta/gen.go

@@ -0,0 +1,80 @@
+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("all-your-base", &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
+	InputBase   int   `json:"input_base"`
+	InputDigits []int `json:"input_digits"`
+	OutputBase  int   `json:"output_base"`
+	Expected    interface{}
+}
+
+func (o oneCase) Result() []int {
+	s, ok := o.Expected.([]interface{})
+	if !ok {
+		return nil
+	}
+	var res []int
+	for _, v := range s {
+		f, _ := v.(float64)
+		res = append(res, int(f))
+	}
+	return res
+}
+func (o oneCase) Err() string {
+	m, ok := o.Expected.(map[string]interface{})
+	if !ok {
+		return ""
+	}
+	return m["error"].(string)
+}
+
+// Template to generate test cases.
+var tmpl = `package allyourbase
+
+{{.Header}}
+
+var testCases = []struct {
+	description	string
+	inputBase	int
+	inputDigits	[]int
+	outputBase	int
+	expected    []int
+	err         string
+}{ {{range .J.Cases}}
+{
+	description:	{{printf "%q"  .Description}},
+	inputBase:		{{printf "%d"  .InputBase}},
+	inputDigits:		{{printf "%#v"  .InputDigits}},
+	outputBase:	{{printf "%d"  .OutputBase}},
+	expected:	{{printf "%#v"  .Result}},
+	err:	{{printf "%q"  .Err}},
+},{{end}}
+}
+`

data/tracks/go/exercises/all-your-base/.meta/hints.md

@@ -0,0 +1,13 @@
+## Implementation
+
+Assumptions:
+1. Zero is always represented in outputs as [0] instead of [].
+2. In no other instances are leading zeroes present in any outputs.
+3. Leading zeroes are accepted in inputs.
+4. An empty sequence of input digits is considered zero, rather than an error.
+
+Handle problem cases by returning an error whose Error() method
+returns one of following messages:
+* input base must be >= 2
+* output base must be >= 2
+* all digits must satisfy 0 <= d < input base

data/tracks/go/exercises/all-your-base/README.md

@@ -6,6 +6,7 @@ Implement general base conversion. Given a number in base **a**,
 represented as a sequence of digits, convert it to base **b**.
 
 ## Note
+
 - Try to implement the conversion yourself.
   Do not use something else to perform the conversion for you.
 
@@ -28,9 +29,23 @@ The number 1120, *in base 3*, means:
 
 I think you got the idea!
 
-
 *Yes. Those three numbers above are exactly the same. Congratulations!*
 
+## Implementation
+
+Assumptions:
+1. Zero is always represented in outputs as [0] instead of [].
+2. In no other instances are leading zeroes present in any outputs.
+3. Leading zeroes are accepted in inputs.
+4. An empty sequence of input digits is considered zero, rather than an error.
+
+Handle problem cases by returning an error whose Error() method
+returns one of following messages:
+* input base must be >= 2
+* output base must be >= 2
+* all digits must satisfy 0 <= d < input base
+
+
 ## Running the tests
 
 To run the tests run the command `go test` from within the exercise directory.

data/tracks/go/exercises/all-your-base/all_your_base_test.go

@@ -1,177 +1,26 @@
 package allyourbase
 
-import "testing"
-
-// Note: ConvertToBase should accept leading zeroes in its input,
-// but never emit leading zeroes in its output.
-// Exception: If the value of the output is zero, represent it with a single zero.
-var testCases = []struct {
-	description  string
-	inputBase    uint64
-	outputBase   uint64
-	inputDigits  []uint64
-	outputDigits []uint64
-	error        error
-}{
-	{
-		description:  "single bit one to decimal",
-		inputBase:    2,
-		inputDigits:  []uint64{1},
-		outputBase:   10,
-		outputDigits: []uint64{1},
-	},
-	{
-		description:  "binary to single decimal",
-		inputBase:    2,
-		inputDigits:  []uint64{1, 0, 1},
-		outputBase:   10,
-		outputDigits: []uint64{5},
-	},
-	{
-		description:  "single decimal to binary",
-		inputBase:    10,
-		inputDigits:  []uint64{5},
-		outputBase:   2,
-		outputDigits: []uint64{1, 0, 1},
-	},
-	{
-		description:  "binary to multiple decimal",
-		inputBase:    2,
-		inputDigits:  []uint64{1, 0, 1, 0, 1, 0},
-		outputBase:   10,
-		outputDigits: []uint64{4, 2},
-	},
-	{
-		description:  "decimal to binary",
-		inputBase:    10,
-		inputDigits:  []uint64{4, 2},
-		outputBase:   2,
-		outputDigits: []uint64{1, 0, 1, 0, 1, 0},
-	},
-	{
-		description:  "trinary to hexadecimal",
-		inputBase:    3,
-		inputDigits:  []uint64{1, 1, 2, 0},
-		outputBase:   16,
-		outputDigits: []uint64{2, 10},
-	},
-	{
-		description:  "hexadecimal to trinary",
-		inputBase:    16,
-		inputDigits:  []uint64{2, 10},
-		outputBase:   3,
-		outputDigits: []uint64{1, 1, 2, 0},
-	},
-	{
-		description:  "15-bit integer",
-		inputBase:    97,
-		inputDigits:  []uint64{3, 46, 60},
-		outputBase:   73,
-		outputDigits: []uint64{6, 10, 45},
-	},
-	{
-		description:  "empty list",
-		inputBase:    2,
-		inputDigits:  []uint64{},
-		outputBase:   10,
-		outputDigits: []uint64{0},
-		error:        nil,
-	},
-	{
-		description:  "single zero",
-		inputBase:    10,
-		inputDigits:  []uint64{0},
-		outputBase:   2,
-		outputDigits: []uint64{0},
-	},
-	{
-		description:  "multiple zeros",
-		inputBase:    10,
-		inputDigits:  []uint64{0, 0, 0},
-		outputBase:   2,
-		outputDigits: []uint64{0},
-	},
-	{
-		description:  "leading zeros",
-		inputBase:    7,
-		inputDigits:  []uint64{0, 6, 0},
-		outputBase:   10,
-		outputDigits: []uint64{4, 2},
-	},
-	{
-		description:  "invalid positive digit",
-		inputBase:    2,
-		inputDigits:  []uint64{1, 2, 1, 0, 1, 0},
-		outputBase:   10,
-		outputDigits: nil,
-		error:        ErrInvalidDigit,
-	},
-	{
-		description:  "first base is one",
-		inputBase:    1,
-		inputDigits:  []uint64{},
-		outputBase:   10,
-		outputDigits: nil,
-		error:        ErrInvalidBase,
-	},
-	{
-		description:  "second base is one",
-		inputBase:    2,
-		inputDigits:  []uint64{1, 0, 1, 0, 1, 0},
-		outputBase:   1,
-		outputDigits: nil,
-		error:        ErrInvalidBase,
-	},
-	{
-		description:  "first base is zero",
-		inputBase:    0,
-		inputDigits:  []uint64{},
-		outputBase:   10,
-		outputDigits: nil,
-		error:        ErrInvalidBase,
-	},
-	{
-		description:  "second base is zero",
-		inputBase:    10,
-		inputDigits:  []uint64{7},
-		outputBase:   0,
-		outputDigits: nil,
-		error:        ErrInvalidBase,
-	},
-}
-
-func digitsEqual(a, b []uint64) bool {
-	if len(a) != len(b) {
-		return false
-	}
-
-	for i := 0; i < len(a); i++ {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-
-	return true
-}
+import (
+	"reflect"
+	"testing"
+)
 
 func TestConvertToBase(t *testing.T) {
 	for _, c := range testCases {
 		output, err := ConvertToBase(c.inputBase, c.inputDigits, c.outputBase)
-		if err != c.error {
+		if c.err != "" && (err == nil || c.err != err.Error()) {
 			t.Fatalf(`FAIL: %s
-	Expected error: %v
-	Got: %v`, c.description, c.error, err)
+	Expected error: %s
+	Got: %v`, c.description, c.err, err)
 		}
-
-		if !digitsEqual(c.outputDigits, output) {
+		if !reflect.DeepEqual(c.expected, output) {
 			t.Fatalf(`FAIL: %s
     Input base: %d
-    Input digits: %v
+    Input digits: %#v
     Output base: %d
-    Expected output digits: %v
-    Got: %v`, c.description, c.inputBase, c.inputDigits, c.outputBase, c.outputDigits, output)
-		} else {
-			t.Logf("PASS: %s", c.description)
+    Expected output digits: %#v
+    Got: %#v`, c.description, c.inputBase, c.inputDigits, c.outputBase, c.expected, output)
 		}
+		t.Logf("PASS: %s", c.description)
 	}
 }

data/tracks/go/exercises/all-your-base/cases_test.go

@@ -0,0 +1,183 @@
+package allyourbase
+
+// Source: exercism/problem-specifications
+// Commit: ba6375e all-your-base: replace 'first' and 'second' with 'input' and 'output' in descriptions
+// Problem Specifications Version: 2.0.1
+
+var testCases = []struct {
+	description string
+	inputBase   int
+	inputDigits []int
+	outputBase  int
+	expected    []int
+	err         string
+}{
+	{
+		description: "single bit one to decimal",
+		inputBase:   2,
+		inputDigits: []int{1},
+		outputBase:  10,
+		expected:    []int{1},
+		err:         "",
+	},
+	{
+		description: "binary to single decimal",
+		inputBase:   2,
+		inputDigits: []int{1, 0, 1},
+		outputBase:  10,
+		expected:    []int{5},
+		err:         "",
+	},
+	{
+		description: "single decimal to binary",
+		inputBase:   10,
+		inputDigits: []int{5},
+		outputBase:  2,
+		expected:    []int{1, 0, 1},
+		err:         "",
+	},
+	{
+		description: "binary to multiple decimal",
+		inputBase:   2,
+		inputDigits: []int{1, 0, 1, 0, 1, 0},
+		outputBase:  10,
+		expected:    []int{4, 2},
+		err:         "",
+	},
+	{
+		description: "decimal to binary",
+		inputBase:   10,
+		inputDigits: []int{4, 2},
+		outputBase:  2,
+		expected:    []int{1, 0, 1, 0, 1, 0},
+		err:         "",
+	},
+	{
+		description: "trinary to hexadecimal",
+		inputBase:   3,
+		inputDigits: []int{1, 1, 2, 0},
+		outputBase:  16,
+		expected:    []int{2, 10},
+		err:         "",
+	},
+	{
+		description: "hexadecimal to trinary",
+		inputBase:   16,
+		inputDigits: []int{2, 10},
+		outputBase:  3,
+		expected:    []int{1, 1, 2, 0},
+		err:         "",
+	},
+	{
+		description: "15-bit integer",
+		inputBase:   97,
+		inputDigits: []int{3, 46, 60},
+		outputBase:  73,
+		expected:    []int{6, 10, 45},
+		err:         "",
+	},
+	{
+		description: "empty list",
+		inputBase:   2,
+		inputDigits: []int{},
+		outputBase:  10,
+		expected:    []int{0},
+		err:         "",
+	},
+	{
+		description: "single zero",
+		inputBase:   10,
+		inputDigits: []int{0},
+		outputBase:  2,
+		expected:    []int{0},
+		err:         "",
+	},
+	{
+		description: "multiple zeros",
+		inputBase:   10,
+		inputDigits: []int{0, 0, 0},
+		outputBase:  2,
+		expected:    []int{0},
+		err:         "",
+	},
+	{
+		description: "leading zeros",
+		inputBase:   7,
+		inputDigits: []int{0, 6, 0},
+		outputBase:  10,
+		expected:    []int{4, 2},
+		err:         "",
+	},
+	{
+		description: "input base is one",
+		inputBase:   1,
+		inputDigits: []int{},
+		outputBase:  10,
+		expected:    []int(nil),
+		err:         "input base must be >= 2",
+	},
+	{
+		description: "input base is zero",
+		inputBase:   0,
+		inputDigits: []int{},
+		outputBase:  10,
+		expected:    []int(nil),
+		err:         "input base must be >= 2",
+	},
+	{
+		description: "input base is negative",
+		inputBase:   -2,
+		inputDigits: []int{1},
+		outputBase:  10,
+		expected:    []int(nil),
+		err:         "input base must be >= 2",
+	},
+	{
+		description: "negative digit",
+		inputBase:   2,
+		inputDigits: []int{1, -1, 1, 0, 1, 0},
+		outputBase:  10,
+		expected:    []int(nil),
+		err:         "all digits must satisfy 0 <= d < input base",
+	},
+	{
+		description: "invalid positive digit",
+		inputBase:   2,
+		inputDigits: []int{1, 2, 1, 0, 1, 0},
+		outputBase:  10,
+		expected:    []int(nil),
+		err:         "all digits must satisfy 0 <= d < input base",
+	},
+	{
+		description: "output base is one",
+		inputBase:   2,
+		inputDigits: []int{1, 0, 1, 0, 1, 0},
+		outputBase:  1,
+		expected:    []int(nil),
+		err:         "output base must be >= 2",
+	},
+	{
+		description: "output base is zero",
+		inputBase:   10,
+		inputDigits: []int{7},
+		outputBase:  0,
+		expected:    []int(nil),
+		err:         "output base must be >= 2",
+	},
+	{
+		description: "output base is negative",
+		inputBase:   2,
+		inputDigits: []int{1},
+		outputBase:  -7,
+		expected:    []int(nil),
+		err:         "output base must be >= 2",
+	},
+	{
+		description: "both bases are negative",
+		inputBase:   -2,
+		inputDigits: []int{1},
+		outputBase:  -7,
+		expected:    []int(nil),
+		err:         "input base must be >= 2",
+	},
+}