trackler 2.1.0.33 → 2.1.0.34

data/tracks/perl6/bin/README.md

@@ -10,25 +10,35 @@ You will either need to create a symlink to or clone the
 into the root directory of this repository.
 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.
+test files using `templates/test.mustache`, and Example.pm6 files using
+`templates/module.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
+plan: 2
 modules:
   - use: Data::Dump
   - use: Foo::Bar
 imports: 'MyClass &my-subroutine'
 methods: 'foo bar'
 tests: |
-  ok True, 'Perl 6 code here';
+  ok my-subroutine, 'Perl 6 code here';
   pass;
+
+unit: module
+example: |
+  sub my-subroutine is export {
+    True;
+  }
+  
+  class MyClass is export {
+  }
 ```
 
 You must have `Template::Mustache` and `YAMLish` to run `exercise-gen.pl6`.
 
-Note (2017-05-22): [YAMLish](http://modules.perl6.org/dist/YAMLish) is not yet feature complete, so some valid YAML files may not parse.
+Note (2017-05-22): [YAMLish](http://modules.perl6.org/dist/YAMLish)
+is not yet feature complete, so some valid YAML files may not parse.

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

@@ -8,7 +8,7 @@ my @exercises;
 
 if @*ARGS {
   if @*ARGS[0] eq '--all' {
-    push @exercises, $_.basename for $base-dir.child('exercises').dir;
+    push @exercises, .basename for $base-dir.child('exercises').dir;
   } else {
     @exercises = @*ARGS;
   }
@@ -23,14 +23,29 @@ if @*ARGS {
 }
 
 for @exercises -> $exercise {
+  say "Generating $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;
+  $_=.chomp when Str for @(%data.values);
+
+  my $cdata = $base-dir.child("x-common/exercises/$exercise/canonical-data.json");
+  %data<cdata> = :json($cdata.slurp) if $cdata ~~ :f;
+
+  create-file "$exercise.t", 'test';
+
+  %data<module_file> = %data<example>;
+  create-file |<Example.pm6 module>;
+
+  %data<module_file> = %data<stub>;
+  create-file "{%data<exercise>}.pm6", 'module';
 
-  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.";
+
+  sub create-file ($filename, $template) {
+    spurt (my $file = $exercise-dir.child($filename)),
+      Template::Mustache.render($base-dir.child("templates/$template.mustache").slurp, %data);
+    $file.chmod(0o755) if $template ~~ 'test';
+  }
 }

data/tracks/perl6/exercises/accumulate/example.yaml

@@ -21,3 +21,13 @@ tests: |
   is-deeply accumulate(['the', 'quick', 'brown', 'fox'], sub { @_[0].flip }),
             ['eht', 'kciuq', 'nworb', 'xof'],
             'reverse strings';
+
+unit: module
+example: |
+  sub accumulate (@list, $function) is export {
+    my @accumulated;
+    for @list -> $element {
+      @accumulated.push: $function($element);
+    }
+    return @accumulated;
+  }

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

@@ -23,6 +23,7 @@ require ::($module) <&convert-base>;
 
 my $c-data;
 sub test ($case, $expected) { is-deeply &::('convert-base')(|$case<input_base input_digits output_base>), $expected, $case<description> }
+
 for @($c-data<cases>) {
   when .<expected> ~~ Array { test $_, .<expected> }
   when .<description> ~~ /base|digit/ { throws-like {&::('convert-base')(|.<input_base input_digits output_base>)}, Exception, .<description> }

data/tracks/perl6/exercises/all-your-base/example.yaml

@@ -4,6 +4,7 @@ plan: 23
 imports: '&convert-base'
 tests: |
   sub test ($case, $expected) { is-deeply &::('convert-base')(|$case<input_base input_digits output_base>), $expected, $case<description> }
+  
   for @($c-data<cases>) {
     when .<expected> ~~ Array { test $_, .<expected> }
     when .<description> ~~ /base|digit/ { throws-like {&::('convert-base')(|.<input_base input_digits output_base>)}, Exception, .<description> }
@@ -12,3 +13,51 @@ tests: |
     when .<description> ~~ /zero/ { test $_, [0] }
     default { flunk .<description> } # To ensure that no canonical-data cases are missed.
   }
+
+unit: module
+example: |
+  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 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;
+  }
+  
+  sub from-decimal ($output-base, $dec) {
+    my @output-digits;
+    my $num = $dec;
+    while $num >= $output-base {
+      unshift @output-digits, $num % $output-base;
+      $num div= $output-base;
+    }
+    unshift @output-digits, $num;
+    return @output-digits;
+  }
+

data/tracks/perl6/exercises/allergies/Allergies.pm6

@@ -1 +1 @@
-unit module Allergies:ver<1>;
+unit module Allergies:ver<1>;

data/tracks/perl6/exercises/allergies/example.yaml

@@ -19,3 +19,24 @@ tests: |
       }
     } if %cases<description> ~~ 'list';
   }
+
+unit: module
+example: |
+  our @allergens = <
+      eggs
+      peanuts
+      shellfish
+      strawberries
+      tomatoes
+      chocolate
+      pollen
+      cats
+  >;
+  
+  sub allergic-to($code,$substance) is export {
+      return so $code +& ( 2 ** @allergens.first({ $_ eq $substance},:k) )
+  }
+  
+  sub list-allergies($code) is export {
+      return grep { allergic-to($code,$_) }, @allergens;
+  }

data/tracks/perl6/exercises/anagram/example.yaml

@@ -4,3 +4,22 @@ plan: 18
 imports: '&match-anagrams'
 tests: |
   is match-anagrams(|.<subject candidates>), |.<expected description> for @($c-data<cases>);
+
+unit: module
+example: |
+  sub match-anagrams ($word, @words) is export {
+    my @results;
+    my $canonical = canonize($word);
+    for @words -> $w {
+      next if $w.lc eq $word.lc;
+      my $try = canonize($w);
+      if $try eq $canonical {
+        @results.push: $w;
+      }
+    }
+    @results;
+  }
+  
+  sub canonize ($str) {
+    (($str.lc.split('')).sort).join('');
+  }

data/tracks/perl6/exercises/atbash-cipher/AtbashCipher.pm6

@@ -1 +1 @@
-unit module AtbashCipher:ver<1>;
+unit module AtbashCipher:ver<1>;

data/tracks/perl6/exercises/atbash-cipher/example.yaml

@@ -11,3 +11,18 @@ tests: |
       is &::($test)(.<phrase>), |.<expected description> for @cases;
     }
   }
+
+unit: module
+example: |
+  sub encode($input) is export {
+      decode($input.lc.trans( ['a'..'z', 0..9] => '', :complement ) )
+          .comb(5)
+          .join: ' ';
+  }
+  
+  sub decode (Str $input) is export {
+      return $input
+              .lc
+              .subst( /\W/, '', :g )
+              .trans( [ 'a'..'z' ] =>  ['a'..'z'].reverse );
+  }

data/tracks/perl6/exercises/bob/Example.pm6

@@ -1,3 +1,7 @@
+#`[
+  Declare class 'Bob' with version and unit-scope the class
+  i.e. everything in this file is part of 'Bob'.
+]
 unit class Bob:ver<1>;
 
 method hey ($msg) {

data/tracks/perl6/exercises/bob/example.yaml

@@ -18,3 +18,27 @@ methods_comment: "Check that the class 'Bob' can use all of the methods\nneeded
 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!)"
+
+unit: class
+unit_comment: |
+  #`[
+    Declare class 'Bob' with version and unit-scope the class
+    i.e. everything in this file is part of 'Bob'.
+  ]
+example: |
+  method hey ($msg) {
+    given $msg.trim {
+      when !*                        { 'Fine. Be that way!' }
+      when /<:Upper>/ and $_.uc eq * { 'Whoa, chill out!'   }
+      when /'?'$/                    { 'Sure.'              }
+      default                        { 'Whatever.'          }
+    }
+  }
+stub: |
+  method hey ($msg) {
+    #`[
+      Remove the comments and write some code here to pass the test suite.
+      You can experiment with the code outside of this block,
+      but no changes are needed for the test suite to pass.
+    ]
+  }

data/tracks/perl6/exercises/clock/clock.t

@@ -44,6 +44,7 @@ for @($c-data<cases>) {
     }
   }
 }
+
 todo 'optional test' unless %*ENV<EXERCISM>;
 is ::($exercise).new(:0hour,:0minute).?add-minutes(65).?time, '01:05', 'add-minutes method can be chained';
 

data/tracks/perl6/exercises/clock/example.yaml

@@ -23,5 +23,22 @@ tests: |
       }
     }
   }
+  
   todo 'optional test' unless %*ENV<EXERCISM>;
   is ::($exercise).new(:0hour,:0minute).?add-minutes(65).?time, '01:05', 'add-minutes method can be chained';
+
+unit: class
+example: |
+  has Int:D $.hour = 0;
+  has Int:D $.minute = 0;
+  
+  method time {
+    sprintf '%02d:%02d', ($!hour + $!minute div 60) % 24, $!minute % 60;
+  }
+  
+  method add-minutes (Int:D $min) {
+    $!minute += $min and return self;
+  }
+stub: |
+  has $.hour;
+  has $.minute;

data/tracks/perl6/exercises/flatten-array/example.yaml

@@ -4,3 +4,20 @@ plan: 8
 imports: '&flatten-array'
 tests: |
   is-deeply &::('flatten-array')(.<input>), |.<expected description> for @($c-data<cases>);
+
+unit: module
+example: |
+  sub flatten-array(@input --> Array) is export {
+    @input.&denest;
+    return my @result;
+  
+    sub denest(@array) {
+      for @array {
+        .&denest when Array;
+        @result.push: $_ when Int;
+      }
+    }
+  }
+stub: |
+  sub flatten-array(@input) is export {
+  }

data/tracks/perl6/exercises/grade-school/example.yaml

@@ -21,3 +21,25 @@ tests: |
     ok $roster.?add-student(:name($_), :3grade), "Add $_ to grade 3" for <Tom Dick Harry>;
   }
   is $roster.?list-all, ('Grade 1', <Anna Barb Charlie>, 'Grade 2', <Alex Jim Zoe>, 'Grade 3', <Dick Harry Tom>), 'List all';
+
+unit: module
+example: |
+  class Roster is export {
+    has %!roster;
+  
+    method add-student (Str:D :$name!, Int:D :$grade!) {
+      %!roster.append($grade, $name);
+    }
+  
+    method list-grade (Int:D $grade --> Seq:D) {
+      %!roster{$grade}.sort;
+    }
+  
+    method list-all {
+      my @list.append("Grade $_", %!roster{$_}.sort) for %!roster.keys.sort;
+      return @list;
+    }
+  }
+stub: |
+  class Roster is export {
+  }

data/tracks/perl6/exercises/grains/example.yaml

@@ -11,3 +11,16 @@ tests: |
     }
   }
   is total-grains, |$c-data<cases>[1]<expected description>;
+
+unit: module
+example: |
+  sub grains-on-square ($number) is export {
+    die if $number < 1 or $number > 64;
+    2**($number-1);
+  }
+  
+  sub total-grains is export {
+    my Int $total;
+    for  1..64 { $total += grains-on-square($_) }
+    $total;
+  }

data/tracks/perl6/exercises/hello-world/Example.pm6

@@ -1,3 +1,12 @@
+#`(
+  This is a 'stub' file. It's a little start on your solution.
+  It is not a complete solution though; you will have to write some code.
+
+  The ':ver<>' adverb defines the version of a module or class.
+  The version is checked in the test suite to ensure the exercise
+  and test suite line up. If the test is updated, it will indicate
+  to others who test your code that some tests may no longer pass.
+)
 unit module HelloWorld:ver<2>;
 
 sub hello is export {

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

@@ -18,3 +18,24 @@ 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!)"
+
+unit: module
+unit_comment: |
+  #`(
+    This is a 'stub' file. It's a little start on your solution.
+    It is not a complete solution though; you will have to write some code.
+  
+    The ':ver<>' adverb defines the version of a module or class.
+    The version is checked in the test suite to ensure the exercise
+    and test suite line up. If the test is updated, it will indicate
+    to others who test your code that some tests may no longer pass.
+  )
+example: |
+  sub hello is export {
+    'Hello, World!'
+  }
+stub: |
+  sub hello is export {
+    # Write your solution to pass the test suite here.
+    # Be sure to remove all stock comments once you are done!
+  }

data/tracks/perl6/exercises/leap/Example.pm6

@@ -1,4 +1,4 @@
-unit module Leap:ver<1>; 
+unit module Leap:ver<1>;
 
 sub is-leap-year ($year) is export {
   is-divisible($year, 400)

data/tracks/perl6/exercises/leap/Leap.pm6

@@ -1,4 +1,4 @@
-unit module Leap:ver<1>; 
+unit module Leap:ver<1>;
 
 sub is-leap-year ($year) is export {
 }