trackler 2.0.8.38 → 2.0.8.39

data/tracks/go/exercises/bowling/example_gen.go

@@ -0,0 +1,117 @@
+// +build ignore
+
+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("bowling", &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
+	Comments []string
+	Cases    []OneCase
+}
+
+// template applied to above data structure generates the Go test cases
+
+type OneCase struct {
+	Description   string
+	Property      string
+	PreviousRolls []int `json:"previous_rolls"`
+	Roll          int
+	Expected      interface{}
+}
+
+// ScoreTest and RollTest help determine which type of test case
+// to generate in the template.
+func (c OneCase) ScoreTest() bool { return c.Property == "score" }
+func (c OneCase) RollTest() bool  { return c.Property == "roll" }
+
+func (c OneCase) Valid() bool {
+	valid, _, _ := determineExpected(c.Expected)
+	return valid
+}
+
+func (c OneCase) Score() int {
+	_, score, _ := determineExpected(c.Expected)
+	return score
+}
+
+func (c OneCase) ExplainText() string {
+	_, _, explainText := determineExpected(c.Expected)
+	return explainText
+}
+
+// determineExpected examines an .Expected interface{} object and determines
+// whether a test case is valid(bool), has a score field, and/or has an expected error,
+// returning valid, score, and error explanation text.
+func determineExpected(expected interface{}) (bool, int, string) {
+	score, ok := expected.(float64)
+	if ok {
+		return ok, int(score), ""
+	}
+	m, ok := expected.(map[string]interface{})
+	if !ok {
+		return false, 0, ""
+	}
+	iError, ok := m["error"].(interface{})
+	if !ok {
+		return false, 0, ""
+	}
+	explainText, ok := iError.(string)
+	return false, 0, explainText
+}
+
+// Template to generate two sets of test cases, one for Score tests and one for Roll tests.
+var tmpl = `package bowling
+
+{{.Header}}
+
+var scoreTestCases = []struct {
+	description    string
+	previousRolls  []int	// bowling rolls to do before the Score() test
+	valid          bool     // true => no error, false => error expected
+	score          int	// when .valid == true, the expected score value
+	explainText    string   // when .valid == false, error explanation text
+}{ {{range .J.Cases}}
+{{if .ScoreTest}}{
+	{{printf "%q"  .Description}},
+	{{printf "%#v" .PreviousRolls}},
+	{{printf "%v"  .Valid}},
+	{{printf "%d"  .Score}},
+	{{printf "%q"  .ExplainText}},
+},{{- end}}{{end}}
+}
+
+var rollTestCases = []struct {
+	description    string
+	previousRolls  []int	// bowling rolls to do before the Roll(roll) test
+	valid          bool     // true => no error, false => error expected
+	roll           int	// pin count for the test roll
+	explainText    string   // when .valid == false, error explanation text
+}{ {{range .J.Cases}}
+{{if .RollTest}}{
+	{{printf "%q"  .Description}},
+	{{printf "%#v" .PreviousRolls}},
+	{{printf "%v"  .Valid}},
+	{{printf "%d"  .Roll}},
+	{{printf "%q"  .ExplainText}},
+},{{- end}}{{end}}
+}
+`

data/tracks/go/exercises/leap/cases_test.go

@@ -1,7 +1,8 @@
 package leap
 
 // Source: exercism/x-common
-// Commit: be6fa53 leap: Rewrite the test cases and their descriptions
+// Commit: cc65ebe leap: Fix canonical-data.json formatting
+// x-common version: 1.0.0
 
 var testCases = []struct {
 	year        int

data/tracks/go/exercises/leap/example_gen.go

@@ -32,9 +32,7 @@ type js struct {
 // template applied to above data structure generates the Go test cases
 var tmpl = `package leap
 
-// Source: {{.Ori}}
-{{if .Commit}}// Commit: {{.Commit}}
-{{end}}
+{{.Header}}
 
 var testCases = []struct {
 	year        int

data/tracks/go/gen/gen.go

@@ -32,6 +32,27 @@ var dirMetadata string
 // Falls back to the present working directory.
 var dirProblem string
 
+// Header tells how the test data was generated, for display in the header of cases_test.go
+type Header struct {
+	// Ori is a deprecated short name for Origin.
+	// TODO: Remove Ori once everything switches to Origin.
+	Ori     string
+	Origin  string
+	Commit  string
+	Version string
+}
+
+func (h Header) String() string {
+	s := fmt.Sprintf("// Source: %s\n", h.Origin)
+	if h.Commit != "" {
+		s += fmt.Sprintf("// Commit: %s\n", h.Commit)
+	}
+	if h.Version != "" {
+		s += fmt.Sprintf("// x-common version: %s\n", h.Version)
+	}
+	return s
+}
+
 func init() {
 	if _, path, _, ok := runtime.Caller(0); ok {
 		dirMetadata = filepath.Join(path, "..", "..", "..", "x-common")
@@ -50,7 +71,7 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
 	}
 	jFile := filepath.Join("exercises", exercise, "canonical-data.json")
 	// find and read the json source file
-	jPath, jOri, jCommit := getPath(jFile)
+	jPath, jOrigin, jCommit := getPath(jFile)
 	jSrc, err := ioutil.ReadFile(filepath.Join(jPath, jFile))
 	if err != nil {
 		return err
@@ -65,12 +86,24 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
 		return fmt.Errorf(`unexpected data structure: %v`, err)
 	}
 
+	// These fields are guaranteed to be in every problem
+	var commonMetadata struct {
+		Version string
+	}
+	if err := json.Unmarshal(jSrc, &commonMetadata); err != nil {
+		return fmt.Errorf(`Didn't contain version: %v`, err)
+	}
+
 	// package up a little meta data
 	d := struct {
-		Ori    string
-		Commit string
-		J      interface{}
-	}{jOri, jCommit, j}
+		Header
+		J interface{}
+	}{Header{
+		Ori:     jOrigin,
+		Origin:  jOrigin,
+		Commit:  jCommit,
+		Version: commonMetadata.Version,
+	}, j}
 
 	// render the Go test cases
 	var b bytes.Buffer
@@ -86,7 +119,7 @@ func Gen(exercise string, j interface{}, t *template.Template) error {
 	return ioutil.WriteFile(filepath.Join(dirProblem, "cases_test.go"), src, 0666)
 }
 
-func getPath(jFile string) (jPath, jOri, jCommit string) {
+func getPath(jFile string) (jPath, jOrigin, jCommit string) {
 	// Ideally draw from a .json which is pulled from the official x-common
 	// repository.  For development however, accept a file in current directory
 	// if there is no .json in source control.  Also allow an override in any

data/tracks/perl6/bin/README.md

@@ -0,0 +1,29 @@
+The `exercise-gen.pl6` file can be used in the following ways:
+* From within the directory of the exercise you wish to generate a test for.
+* With arguments specifying which exercises you want to generate tests for.  
+  e.g. `./exercise-gen.pl6 hello-world leap`
+* With the argument `--all` to run the generator for all exercises.  
+  i.e `./exercise-gen.pl6 --all`
+
+The generator will retrieve data from an `example.yaml` file within
+each exercise directory, and use the contained information to generate
+test files using `templates/test.mustache`. If it finds a
+`canonical-data.json` file in `x-common` for the exercise in
+question it will be included.
+
+Example of a yaml file:
+```yaml
+exercise: MyExercise
+version: 1
+plan: 10
+modules:
+  - use: Data::Dump
+  - use: Foo::Bar
+imports: 'MyClass &my-subroutine'
+methods: 'foo bar'
+tests: |
+  ok True, 'Perl 6 code here';
+  pass;
+```
+
+You must have `Template::Mustache` and `YAMLish` to run `exercise-gen.pl6`.

data/tracks/perl6/bin/exercise-gen.pl6

@@ -0,0 +1,36 @@
+#!/usr/bin/env perl6
+use v6;
+use Template::Mustache;
+use YAMLish;
+
+my $base-dir = $?FILE.IO.resolve.parent.parent;
+my @exercises;
+
+if @*ARGS {
+  if @*ARGS[0] eq '--all' {
+    push @exercises, $_.basename for $base-dir.child('exercises').dir;
+  } else {
+    @exercises = @*ARGS;
+  }
+} else {
+  say 'No args given; working in current directory.';
+  if 'example.yaml'.IO ~~ :f {
+    push @exercises, $*CWD.IO.basename;
+  } else {
+    say 'example.yaml not found; exiting.';
+    exit;
+  }
+}
+
+for @exercises -> $exercise {
+  my $exercise-dir = $base-dir.child("exercises/$exercise");
+  next if (my $yaml = $exercise-dir.child('example.yaml')) !~~ :f;
+  my $cdata = $base-dir.child("x-common/exercises/$exercise/canonical-data.json");
+  my %data = load-yaml $yaml.slurp;
+  %data<cdata> = {:json($cdata.slurp)} if $cdata ~~ :f;
+
+  spurt (my $test = $exercise-dir.child("$exercise.t")),
+    Template::Mustache.render($base-dir.child('templates/test.mustache').slurp, %data);
+  $test.chmod(0o755);
+  say "$exercise generated.";
+}

data/tracks/perl6/config.json

@@ -11,6 +11,7 @@
   ],
   "ignored": [
     "docs",
+    "templates",
     "x-common",
     "img"
   ],

data/tracks/perl6/exercises/hello-world/example.yaml

@@ -0,0 +1,19 @@
+exercise: HelloWorld
+version: 2
+plan: 3
+imports: '&hello'
+tests: |
+  #`[Go through the cases (hiding at the bottom of this file)
+  and check that &hello gives us the correct response.]
+  is &::('hello')(), |.<expected description> for @($c-data<cases>);
+
+exercise_comment: The name of this exercise.
+module_comment: "%*ENV<EXERCISM> is for tests not directly for the exercise, don't worry about these :)"
+version_comment: The version we will be matching against the exercise.
+plan_comment: This is how many tests we expect to run.
+use_test_comment: Check that the module can be use-d.
+version_test_comment: "If the exercise is updated, we want to make sure other people testing\nyour code don't think you've made a mistake if things have changed!"
+imports_comment: Import '&hello' from 'HelloWorld'
+cdata_test_comment: Ignore this for your exercise! Tells Exercism folks when exercise cases become out of date.
+done_testing_comment: There are no more tests after this :)
+INIT_comment: "'INIT' is a phaser, it makes sure that the test data is available before everything else\nstarts running (otherwise we'd have to shove the test data into the middle of the file!)"

data/tracks/perl6/templates/test.mustache

@@ -0,0 +1,53 @@
+#!/usr/bin/env perl6
+use v6;{{=#`{{ }}=}}#`{{! Mustache tags double up as Perl 6 embedded comments}}
+use Test;
+use lib #`{{#cdata}}my $dir = #`{{/cdata}}$?FILE.IO.dirname;#`{{#lib_comment}} #`[#`{{&lib_comment}}]#`{{/lib_comment}}
+#`{{#cdata}}use JSON::Tiny;
+#`{{/cdata}}#`{{#modules}}use #`{{&use}};
+#`{{/modules}}
+
+my $exercise#`{{#exercise}} = '#`{{&exercise}}'#`{{/exercise}};#`{{#exercise_comment}} #`[#`{{&exercise_comment}}]#`{{/exercise_comment}}
+my $version#`{{#version}} = v#`{{&version}}#`{{/version}};#`{{#version_comment}} #`[#`{{&version_comment}}]#`{{/version_comment}}
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;#`{{#module_comment}} #`[#`{{&module_comment}}]#`{{/module_comment}}#`{{#plan}}
+plan #`{{&plan}};#`{{#plan_comment}} #`[#`{{&plan_comment}}]#`{{/plan_comment}}#`{{/plan}}
+#`{{#use_test_comment}}
+
+#`[#`{{&use_test_comment}}]#`{{/use_test_comment}}
+use-ok $module or bail-out;
+require ::($module);
+#`{{#version_test_comment}}
+
+#`[#`{{&version_test_comment}}]#`{{/version_test_comment}}
+if ::($exercise).^ver !~~ $version {
+  warn "\nExercise version mismatch. Further tests may fail!"
+    ~ "\n$exercise is $(::($exercise).^ver.gist). "
+    ~ "Test is $($version.gist).\n";
+  bail-out 'Example version must match test version.' if %*ENV<EXERCISM>;
+}
+#`{{#imports}}#`{{#imports_comment}}
+#`[#`{{&imports_comment}}]#`{{/imports_comment}}
+require ::($module) <#`{{&imports}}>;
+#`{{/imports}}#`{{#methods}}#`{{#methods_comment}}
+#`[#`{{&methods_comment}}]#`{{/methods_comment}}
+subtest 'Class methods', {
+  ok ::($exercise).can($_), $_ for <#`{{&methods}}>;
+}
+#`{{/methods}}#`{{#cdata}}
+my $c-data;#`{{/cdata}}
+#`{{&tests}}#`{{#cdata}}#`{{#cdata_test_comment}}
+#`[#`{{&cdata_test_comment}}]#`{{/cdata_test_comment}}
+if %*ENV<EXERCISM> && (my $c-data-file =
+  "$dir/../../x-common/exercises/{$dir.IO.resolve.basename}/canonical-data.json".IO.resolve) ~~ :f
+{ is-deeply $c-data, from-json($c-data-file.slurp), 'canonical-data' } else { skip }
+#`{{/cdata}}
+
+done-testing;#`{{#done_testing_comment}} #`[#`{{&done_testing_comment}}]#`{{/done_testing_comment}}#`{{#cdata}}
+#`{{#INIT_comment}}
+
+#`[#`{{&INIT_comment}}]#`{{/INIT_comment}}
+INIT {
+$c-data := from-json q:to/END/;
+
+#`{{&json}}
+END
+}#`{{/cdata}}

data/tracks/python/.travis.yml

@@ -18,7 +18,7 @@ install:
   - pip install -r requirements-travis.txt
 
 before_script:
-  - flake8 ./exercises/ --max-line-length=99 --select=E,W
+  - flake8
 
 script:
   - ./test/check-exercises.py

data/tracks/python/README.md

@@ -34,13 +34,9 @@ python test/check-exercises.py
 
 ## Code Style
 
-The Python code in this repo is meant to largely obey the [PEP8 style guide](https://www.python.org/dev/peps/pep-0008/).
+The Python code in this repo is meant to follow the [PEP8 style guide](https://www.python.org/dev/peps/pep-0008/).
 
-This repo uses [flake8](http://flake8.readthedocs.org/en/latest/) to enforce the coding standard. When you submit a PR, it needs to pass the flake8 tool with no warnings, or it won't be accepted. Here are the settings used by the build system:
-
-```
-flake8 [your-code-here.py] --max-line-length=99 --select=E,W
-```
+This repo uses [flake8](http://flake8.readthedocs.org/en/latest/) with default settings to enforce the coding standard. When you submit a PR, it needs to pass the flake8 tool with no warnings, or it won't be accepted.
 
 ## Pull Requests
 

data/tracks/python/config.json

@@ -101,6 +101,15 @@
       "topics": [
       ]
     },
+    {
+      "slug": "rotational-cipher",
+      "difficulty": 1,
+      "topics": [
+         "strings",
+         "logic",
+         "control-flow (loops)"
+      ]
+    },
     {
       "slug": "difference-of-squares",
       "difficulty": 1,

data/tracks/python/exercises/anagram/anagram_test.py

@@ -3,69 +3,73 @@ import unittest
 from anagram import detect_anagrams
 
 
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.1
+
 class AnagramTests(unittest.TestCase):
     def test_no_matches(self):
-        self.assertEqual(
-            [],
-            detect_anagrams('diaper', 'hello world zombies pants'.split())
-        )
+        candidates = ["hello", "world", "zombies", "pants"]
+        self.assertEqual(detect_anagrams("diaper", candidates), [])
 
-    def test_detect_simple_anagram(self):
-        self.assertEqual(
-            ['tan'],
-            detect_anagrams('ant', 'tan stand at'.split())
-        )
+    def test_detects_simple_anagram(self):
+        candidates = ["tan", "stand", "at"]
+        self.assertEqual(detect_anagrams("ant", candidates), ["tan"])
 
-    def test_detect_multiple_anagrams(self):
-        self.assertEqual(
-            ['stream', 'maters'],
-            detect_anagrams('master', 'stream pigeon maters'.split())
-        )
+    def test_does_not_detect_false_positives(self):
+        self.assertEqual(detect_anagrams("galea", ["eagle"]), [])
 
-    def test_does_not_confuse_different_duplicates(self):
+    def test_detects_two_anagrams(self):
+        candidates = ["stream", "pigeon", "maters"]
         self.assertEqual(
-            [],
-            detect_anagrams('galea', ['eagle'])
-        )
+            detect_anagrams("master", candidates), ["stream", "maters"])
 
-    def test_eliminate_anagram_subsets(self):
-        self.assertEqual(
-            [],
-            detect_anagrams('good', 'dog goody'.split())
-        )
+    def test_does_not_detect_anagram_subsets(self):
+        self.assertEqual(detect_anagrams("good", ["dog", "goody"]), [])
 
-    def test_detect_anagram(self):
-        self.assertEqual(
-            ['inlets'],
-            detect_anagrams('listen', 'enlists google inlets banana'.split())
-        )
+    def test_detects_anagram(self):
+        candidates = ["enlists", "google", "inlets", "banana"]
+        self.assertEqual(detect_anagrams("listen", candidates), ["inlets"])
 
-    def test_multiple_anagrams(self):
+    def test_detects_three_anagrams(self):
+        candidates = [
+            "gallery", "ballerina", "regally", "clergy", "largely", "leading"
+        ]
         self.assertEqual(
-            'gallery regally largely'.split(),
-            detect_anagrams(
-                'allergy',
-                'gallery ballerina regally clergy largely leading'.split()
-            )
-        )
-
-    def test_anagrams_are_case_insensitive(self):
+            detect_anagrams("allergy", candidates),
+            ["gallery", "regally", "largely"])
+
+    def test_does_not_detect_identical_words(self):
+        candidates = ["corn", "dark", "Corn", "rank", "CORN", "cron", "park"]
+        self.assertEqual(detect_anagrams("corn", candidates), ["cron"])
+
+    def test_does_not_detect_non_anagrams_with_identical_checksum(self):
+        self.assertEqual(detect_anagrams("mass", ["last"]), [])
+
+    def test_detects_anagrams_case_insensitively(self):
+        candidates = ["cashregister", "Carthorse", "radishes"]
         self.assertEqual(
-            ['Carthorse'],
-            detect_anagrams('Orchestra',
-                            'cashregister Carthorse radishes'.split())
-        )
+            detect_anagrams("Orchestra", candidates), ["Carthorse"])
 
-    def test_same_word_isnt_anagram(self):
+    def test_detects_anagrams_using_case_insensitive_subjec(self):
+        candidates = ["cashregister", "carthorse", "radishes"]
         self.assertEqual(
-            [],
-            detect_anagrams('banana', ['banana'])
-        )
+            detect_anagrams("Orchestra", candidates), ["carthorse"])
 
+    def test_detects_anagrams_using_case_insensitive_possible_matches(self):
+        candidates = ["cashregister", "Carthorse", "radishes"]
         self.assertEqual(
-            [],
-            detect_anagrams('go', 'go Go GO'.split())
-        )
+            detect_anagrams("orchestra", candidates), ["Carthorse"])
+
+    def test_does_not_detect_a_word_as_its_own_anagram(self):
+        self.assertEqual(detect_anagrams("banana", ["Banana"]), [])
+
+    def test_does_not_detect_a_anagram_if_the_original_word_is_repeated(self):
+        self.assertEqual(detect_anagrams("go", ["go Go GO"]), [])
+
+    def test_anagrams_must_use_all_letters_exactly_once(self):
+        self.assertEqual(detect_anagrams("tapper", ["patter"]), [])
+
+    def test_capital_word_is_not_own_anagram(self):
+        self.assertEqual(detect_anagrams("BANANA", ["Banana"]), [])
 
 
 if __name__ == '__main__':