trackler 2.2.1.65 → 2.2.1.66

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f5d8b6d5409d0876c5f4a128f8aaca28d581f9c8
-  data.tar.gz: 5a090210fad681fbd4afec72f355de5647b466e8
+  metadata.gz: 3204de800ec7eef566ccc5e2a48e9dd99d70a407
+  data.tar.gz: 8ea801d22c63ea5a884e0b879fcfa80af2f611cb
 SHA512:
-  metadata.gz: edb8c0e07373da1f34e6ea9fd2fbd69ff03fba9cf5f8e04bdb9aac09ed18838a3876b2097b6452c82b1a5b62113dce996e3b76eff6f26ed7180b0f54a9ad359c
-  data.tar.gz: 7d963ed89adbedb458b719c11cc6ebd53b7428dfc9b8157c075aca8e468b5566a18341881fcfe841d437ea4e2c2f7a5239be4aa75c9747ddd79df2f82611e5f8
+  metadata.gz: d62a8b637aaa23601fe7bf220d463a4ed3d01382bbc2648495ba884da180c05ff14926ff0009a937dc2c63e0f3570365bd1777e32ee655dade7cf3050366b670
+  data.tar.gz: f40ff5b7155f9837e9d8c5bd5a73e04ffc89e043295d56fc32be38c168db4342bca2696e62e6849a0c642344c22f2f16f5b36fd52c2a60771c032c06784a577d

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.65"
+  VERSION = "2.2.1.66"
 end

data/problem-specifications/exercises/reverse-string/canonical-data.json

@@ -1,12 +1,12 @@
 {
   "exercise": "reverse-string",
-  "version": "1.0.0",      
+  "version": "1.0.1",      
   "comments": [
         "If property based testing tools are available, a good property to test is reversing a string twice: reverse(reverse(string)) == string"
       ],
   "cases": [
     {
-      "description": "empty string",
+      "description": "an empty string",
       "property": "reverse",
       "input": "",
       "expected": ""
@@ -36,4 +36,4 @@
       "expected": "racecar"
     }
   ]
-}
+}

data/tracks/c/exercises/hello-world/makefile

@@ -1,13 +1,22 @@
 CFLAGS  = -std=c99
+CFLAGS += -g
 CFLAGS += -Wall
 CFLAGS += -Wextra
 CFLAGS += -pedantic
 CFLAGS += -Werror
 
+VFLAGS  = --quiet
+VFLAGS += --tool=memcheck
+VFLAGS += --leak-check=full
+VFLAGS += --error-exitcode=1
 
 test: tests.out
 	@./tests.out
 
+memcheck: tests.out
+	@valgrind $(VFLAGS) ./tests.out
+	@echo "Memory check passed"
+
 clean:
 	rm -f *.o *.out
 

data/tracks/c/exercises/phone-number/test/test_phone_number.c

@@ -2,7 +2,7 @@
 #include "../src/phone_number.h"
 #include <stdlib.h>
 
-char *result;
+static char *result = NULL;
 
 void setUp(void)
 {
@@ -11,6 +11,7 @@ void setUp(void)
 void tearDown(void)
 {
    free(result);
+   result = NULL;
 }
 
 void test_cleans_parens_dashes_and_spaces_from_the_number(void)

data/tracks/go/exercises/collatz-conjecture/.meta/gen.go

@@ -0,0 +1,72 @@
+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("collatz-conjecture", &j, t); err != nil {
+		log.Fatal(err)
+	}
+}
+
+type OneCase struct {
+	Description string
+	Number      int
+	Expected    interface{}
+}
+
+// The JSON structure we expect to be able to unmarshal into
+type js struct {
+	Cases []OneCase
+}
+
+func (c OneCase) Valid() bool {
+	valid, _ := determineExpected(c.Expected)
+	return valid
+}
+
+func (c OneCase) Answer() int {
+	_, answer := determineExpected(c.Expected)
+	return answer
+}
+
+// determineExpected examines an .Expected interface{} object and determines
+// whether a test case is valid(bool) and has an answer or expects an error.
+// returning valid and answer.
+func determineExpected(expected interface{}) (bool, int) {
+	ans, ok := expected.(float64)
+	if ok {
+		return ok, int(ans)
+	}
+	return false, 0
+}
+
+// template applied to above data structure generates the Go test cases
+var tmpl = `package collatzconjecture
+
+{{.Header}}
+
+var testCases = []struct {
+	description string
+	input       int
+	expectError bool
+	expected    int
+}{
+{{range .J.Cases}}{
+	description:	"{{.Description}}",
+	input:		{{.Number}},
+{{if .Valid}} expected:	{{.Answer}},
+{{- else}} expectError: true,
+{{- end}}
+},
+{{end}}}
+`

data/tracks/go/exercises/collatz-conjecture/cases_test.go

@@ -0,0 +1,43 @@
+package collatzconjecture
+
+// Source: exercism/problem-specifications
+// Commit: 25c4479 Collatz-conjecture: remove trailing space in test name (#839)
+// Problem Specifications Version: 1.1.1
+
+var testCases = []struct {
+	description string
+	input       int
+	expectError bool
+	expected    int
+}{
+	{
+		description: "zero steps for one",
+		input:       1,
+		expected:    0,
+	},
+	{
+		description: "divide if even",
+		input:       16,
+		expected:    4,
+	},
+	{
+		description: "even and odd steps",
+		input:       12,
+		expected:    9,
+	},
+	{
+		description: "Large number of even and odd steps",
+		input:       1000000,
+		expected:    152,
+	},
+	{
+		description: "zero is an error",
+		input:       0,
+		expectError: true,
+	},
+	{
+		description: "negative value is an error",
+		input:       -15,
+		expectError: true,
+	},
+}

data/tracks/go/exercises/collatz-conjecture/collatz_conjecture_test.go

@@ -4,48 +4,6 @@ import (
 	"testing"
 )
 
-var testCases = []struct {
-	description string
-	input       int
-	expectError bool
-	expected    int
-}{
-	{
-		description: "zero steps for one",
-		input:       1,
-		expectError: false,
-		expected:    0,
-	},
-	{
-		description: "divide if even",
-		input:       16,
-		expectError: false,
-		expected:    4,
-	},
-	{
-		description: "even and old steps",
-		input:       12,
-		expectError: false,
-		expected:    9,
-	},
-	{
-		description: "large number of even and odd steps",
-		input:       1000000,
-		expectError: false,
-		expected:    152,
-	},
-	{
-		description: "zero is an error",
-		input:       0,
-		expectError: true,
-	},
-	{
-		description: "negative value is an error",
-		input:       -15,
-		expectError: true,
-	},
-}
-
 func TestCollatzConjecture(t *testing.T) {
 	for _, testCase := range testCases {
 		steps, err := CollatzConjecture(testCase.input)

data/tracks/perl6/config.json

@@ -98,6 +98,16 @@
 
       ]
     },
+    {
+      "uuid": "0313a0a8-0d35-f480-7dce-65154edf4e804d52dc1",
+      "slug": "nucleotide-count",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 3,
+      "topics": [
+
+      ]
+    },
     {
       "uuid": "9fc9b102-185d-4f34-98d0-e3084399610a",
       "slug": "clock",

data/tracks/perl6/docs/ABOUT.md

@@ -1,15 +1,24 @@
-From [Perl 6 Introduction](http://perl6intro.com/):
+Perl 6 is a clean, modern, multi-paradigm language; it offers procedural,
+object-oriented AND functional programming methodologies. It is a supremely
+flexible language, adapting to your style of programming, whether that be quick
+one­liners for sysadmins, scripts to manage a database import, or the full stack
+of modules necessary to realise an entire website.
 
-## What is Perl 6
-Perl 6 is a high-level, general-purpose, gradually typed language. Perl 6 is multi-paradigmatic. It supports Procedural, Object Oriented, and Functional programming.
+Perl 6 enhances Perl’s long­term appeal with a proper object system including
+roles, threading and multi­method dispatch. It has spent a long time coming to
+fruition and has learned from other programming languages, building on their
+success and learning from the issues of the past. We believe Perl 6 is a
+language that will last for decades as it has been conceived to adapt to future
+trends and is flexible in its usage with other languages.
 
-##### Perl 6 motto:
-* TMTOWTDI (Pronounced Tim Toady): There is more than one way to do it.
-* Easy things should stay easy, hard things should get easier, and impossible things should get hard.
+Perl 6 learns from other languages. For instance: taking threading from Java
+(simplified to a handful of methods); Foreign-function interfaces from Lisp make
+accessing libraries as simple as one line of code. Regular expressions are now
+turned up to 11 with the introduction of Parser Expression Grammars, which let
+you tackle huge parsing tasks. Strictures and warnings are now automatic,
+cutting out huge swathes of potential errors.
 
-## Jargon
-* **Perl 6:** Is a language specification with a test suite. Implementations that pass the specification test suite are considered Perl 6.
-* **Rakudo:** Is a compiler for Perl 6.
-* **Rakudobrew:** Is an installation manager for Rakudo.
-* **Zef:** Is a Perl 6 module installer.
-* **Rakudo Star:** Is a bundle that includes Rakudo, Zef, a collection of Perl 6 modules, and documentation.
+Perl 6’s mottos remain the same as Perl: “Perl is different. In a nutshell,
+Perl is designed to make the easy jobs easy, without making the hard jobs
+impossible.” and “There Is More Than One Way To Do It”. Now with even more
+-Ofun (optimized for fun) added.

data/tracks/perl6/exercises/all-your-base/AllYourBase.pm6

@@ -1 +1,4 @@
-unit module AllYourBase:ver<2>;
+unit module AllYourBase:ver<3>;
+
+sub convert-base (:%bases!, :@digits!) is export {
+}

data/tracks/perl6/exercises/all-your-base/Example.pm6

@@ -1,46 +1,26 @@
-unit module AllYourBase:ver<2>;
+unit module AllYourBase:ver<3>;
 
-class X::AllYourBase::InvalidBase is Exception {
-  has $.payload;
-  method message {"$!payload is not a valid base."}
-}
-
-class X::AllYourBase::InvalidDigit is Exception {
-  has %.payload;
-  method message {"%!payload<digit> is not a valid digit for base %!payload<base>."}
-}
-
-sub convert-base (Int:D $input-base, @input-digits, Int:D $output-base --> Array:D) is export {
-  for $input-base, $output-base {
-    X::AllYourBase::InvalidBase.new(payload => $_).throw if $_ < 2;
-  }
-  from-decimal($output-base, (to-decimal $input-base, @input-digits));
+sub convert-base (
+  :%bases! where all(.keys ~~ <from to>.Set, .values.all > 1),
+  :@digits! where %bases<from> > .all ~~ UInt:D,
+  --> Array[UInt:D]
+) is export {
+  from-decimal %bases<to>, to-decimal(%bases<from>, @digits);
 }
 
 sub to-decimal ($input-base, @input-digits) {
-  return [].Slip if !@input-digits;
   my $elems = @input-digits.elems;
-  for @input-digits {
-    if $_ == 0 { $elems-- }
-    else { last }
-  }
-  my $dec = 0;
-  loop (my $i = 0; $i < $elems; $i++) {
-    if @input-digits.reverse[$i] < 0 || @input-digits.reverse[$i] >= $input-base {
-      X::AllYourBase::InvalidDigit.new( :payload(base => $input-base, digit => @input-digits.reverse[$i]) ).throw;
-    }
-    $dec += @input-digits.reverse[$i] * $input-base ** $i;
-  }
-  return $dec;
+  $_ == 0 ?? $elems-- !! last for @input-digits;
+  (loop (my $i = 0; $i < $elems; $i++) {
+    @input-digits.reverse[$i] * $input-base ** $i;
+  }).sum;
 }
 
-sub from-decimal ($output-base, $dec) {
-  my @output-digits;
-  my $num = $dec;
+sub from-decimal ($output-base, $num is copy) {
+  my UInt:D @output-digits;
   while $num >= $output-base {
     unshift @output-digits, $num % $output-base;
     $num div= $output-base;
   }
-  unshift @output-digits, $num;
-  return @output-digits;
+  @output-digits.unshift: $num;
 }

data/tracks/perl6/exercises/all-your-base/all-your-base.t

@@ -5,7 +5,7 @@ use lib my $dir = $?FILE.IO.dirname;
 use JSON::Fast;
 
 my Str:D $exercise := 'AllYourBase';
-my Version:D $version = v2;
+my Version:D $version = v3;
 my Str $module //= $exercise;
 plan 23;
 
@@ -22,26 +22,22 @@ if ::($exercise).^ver !~~ $version {
 require ::($module) <&convert-base>;
 
 my $c-data = from-json $=pod.pop.contents;
-
-for @($c-data<cases>) -> $case {
-  if $case<expected> ~~ Array:D { test }
-  else {
-    given $case<description> {
-      when 'empty list' { test [] }
-      when /base|digit/ { throws-like {call-convert-base}, Exception, $_ }
-      when /zero/ {
-        when 'leading zeros' { test [4,2] }
-        default { test [0] }
-      }
-      flunk "$_; not tested" if %*ENV<EXERCISM>; # To ensure that no canonical-data cases are missed.
-    }
+for $c-data<cases>.values -> $case {
+  sub call-convert-base {
+    convert-base(
+      bases  => %(<from to> Z=> .<input_base output_base>),
+      digits => .<input_digits>,
+    ) given $case;
   }
 
-  sub test (Array:D $expected = $case<expected>) {
-    is-deeply call-convert-base, $expected, $case<description>
+  given $case {
+    if .<expected><error> {
+      throws-like {call-convert-base}, Exception, .<description>;
+    }
+    else {
+      cmp-ok call-convert-base, ‘~~’, |.<expected description>;
+    }
   }
-
-  sub call-convert-base { convert-base(|$case<input_base input_digits output_base>) }
 }
 
 =head2 Canonical Data
@@ -49,24 +45,15 @@ for @($c-data<cases>) -> $case {
 
 {
   "exercise": "all-your-base",
-  "version": "1.1.0",
+  "version": "2.0.1",
   "comments": [
-    "It's up to each track do decide:",
+    "This canonical data makes the following choices:",
+    "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.",
     "",
-    "1. What's the canonical representation of zero?",
-    " - []?",
-    " - [0]?",
-    "",
-    "2. What representations of zero are allowed?",
-    " - []?",
-    " - [0]?",
-    " - [0,0]?",
-    "",
-    "3. Are leading zeroes allowed?",
-    "",
-    "4. How should invalid input be handled?",
-    "",
-    "All the undefined cases are marked as null.",
+    "Tracks that wish to make different decisions for these choices may translate appropriately.",
     "",
     "All your numeric-base are belong to [2..]. :)"
   ],
@@ -141,7 +128,7 @@ for @($c-data<cases>) -> $case {
       "input_base": 2,
       "input_digits": [],
       "output_base": 10,
-      "expected": null
+      "expected": [0]
     },
     {
       "description": "single zero",
@@ -149,7 +136,7 @@ for @($c-data<cases>) -> $case {
       "input_base": 10,
       "input_digits": [0],
       "output_base": 2,
-      "expected": null
+      "expected": [0]
     },
     {
       "description": "multiple zeros",
@@ -157,7 +144,7 @@ for @($c-data<cases>) -> $case {
       "input_base": 10,
       "input_digits": [0, 0, 0],
       "output_base": 2,
-      "expected": null
+      "expected": [0]
     },
     {
       "description": "leading zeros",
@@ -165,31 +152,31 @@ for @($c-data<cases>) -> $case {
       "input_base": 7,
       "input_digits": [0, 6, 0],
       "output_base": 10,
-      "expected": null
+      "expected": [4, 2]
     },
     {
-      "description": "first base is one",
+      "description": "input base is one",
       "property": "rebase",
       "input_base": 1,
       "input_digits": [],
       "output_base": 10,
-      "expected": null
+      "expected": {"error": "input base must be >= 2"}
     },
     {
-      "description": "first base is zero",
+      "description": "input base is zero",
       "property": "rebase",
       "input_base": 0,
       "input_digits": [],
       "output_base": 10,
-      "expected": null
+      "expected": {"error": "input base must be >= 2"}
     },
     {
-      "description": "first base is negative",
+      "description": "input base is negative",
       "property": "rebase",
       "input_base": -2,
       "input_digits": [1],
       "output_base": 10,
-      "expected": null
+      "expected": {"error": "input base must be >= 2"}
     },
     {
       "description": "negative digit",
@@ -197,7 +184,7 @@ for @($c-data<cases>) -> $case {
       "input_base": 2,
       "input_digits": [1, -1, 1, 0, 1, 0],
       "output_base": 10,
-      "expected": null
+      "expected": {"error": "all digits must satisfy 0 <= d < input base"}
     },
     {
       "description": "invalid positive digit",
@@ -205,31 +192,31 @@ for @($c-data<cases>) -> $case {
       "input_base": 2,
       "input_digits": [1, 2, 1, 0, 1, 0],
       "output_base": 10,
-      "expected": null
+      "expected": {"error": "all digits must satisfy 0 <= d < input base"}
     },
     {
-      "description": "second base is one",
+      "description": "output base is one",
       "property": "rebase",
       "input_base": 2,
       "input_digits": [1, 0, 1, 0, 1, 0],
       "output_base": 1,
-      "expected": null
+      "expected": {"error": "output base must be >= 2"}
     },
     {
-      "description": "second base is zero",
+      "description": "output base is zero",
       "property": "rebase",
       "input_base": 10,
       "input_digits": [7],
       "output_base": 0,
-      "expected": null
+      "expected": {"error": "output base must be >= 2"}
     },
     {
-      "description": "second base is negative",
+      "description": "output base is negative",
       "property": "rebase",
       "input_base": 2,
       "input_digits": [1],
       "output_base": -7,
-      "expected": null
+      "expected": {"error": "output base must be >= 2"}
     },
     {
       "description": "both bases are negative",
@@ -237,7 +224,7 @@ for @($c-data<cases>) -> $case {
       "input_base": -2,
       "input_digits": [1],
       "output_base": -7,
-      "expected": null
+      "expected": {"error": "input base must be >= 2"}
     }
   ]
 }