trackler 2.1.0.18 → 2.1.0.19

data/tracks/javascript/config.json

@@ -82,24 +82,37 @@
       "slug": "hello-world",
       "difficulty": 1,
       "topics": [
+        "Control-flow (conditionals)",
+        "Optional values",
+        "Strings",
+        "Text formatting"
       ]
     },
     {
       "slug": "leap",
       "difficulty": 1,
       "topics": [
+        "Booleans",
+        "Integers",
+        "Logic"
       ]
     },
     {
       "slug": "hamming",
       "difficulty": 1,
       "topics": [
+        "Control-flow (loops)",
+        "Control-flow (conditionals)",
+        "Equality",
+        "Strings"
       ]
     },
     {
       "slug": "rna-transcription",
       "difficulty": 1,
       "topics": [
+        "Strings",
+        "Transforming"
       ]
     },
     {
@@ -131,6 +144,7 @@
       "slug": "gigasecond",
       "difficulty": 1,
       "topics": [
+        "Time"
       ]
     },
     {

data/tracks/kotlin/docs/INSTALLATION.md

@@ -12,7 +12,7 @@ Choose your operating system:
 * [Linux](#linux)
 
 ... or ...
-* if you prefer to not use a package maanger, you can [install manually](#install-manually).
+* if you prefer to not use a package manager, you can [install manually](#install-manually).
 
 Optionally, you can also use a [Java IDE](#java-ides).
 

data/tracks/lisp/docs/INSTALLATION.md

@@ -20,6 +20,7 @@ curl -O http://beta.quicklisp.org/quicklisp.lisp
 Now launch lisp, and copy-paste the following expressions to finish QuickLisp installation:
 
 ```lisp
+> (load "quicklisp.lisp")         ;; this will load the downloaded lisp file
 > (quicklisp-quickstart:install)  ;; this will install quicklisp
 > (ql:add-to-init-file)           ;; this will add quicklisp setup to your init file (recommended)
 ```

data/tracks/perl6/README.md

@@ -4,6 +4,15 @@
 
 Exercism exercises in Perl 6
 
+## Contributing Guide
+
+Please see the [contributing guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md).
+
+## Code of Conduct
+
+Help us keep Exercism welcoming. Please read and abide by the
+[Code of Conduct](https://github.com/exercism/exercism.io/blob/master/CODE_OF_CONDUCT.md).
+
 ## Adding and Updating Exercises
 
 Please use `exercise-gen.pl6` in the `bin/` directory when either adding or updating an exercise.
@@ -16,10 +25,6 @@ When adding a new exercise, ensure that the exercise is included in the `exercis
 Set `EXERCISM` as an environment variable (e.g. `export EXERCISM=1` in bash), and run either  `prove -re perl6`
 to run all tests in all subdirectories, or `prove -e perl6 /path/to/test.t` to run an individual test file.
 
-## Contributing Guide
-
-Please see the [contributing guide](https://github.com/exercism/x-api/blob/master/CONTRIBUTING.md#the-exercise-data)
-
 ## License
 
 The MIT License (MIT)

data/tracks/perl6/config.json

@@ -64,6 +64,11 @@
       "slug": "scrabble-score",
       "topics": []
     },
+    {
+      "difficulty": 1,
+      "slug": "luhn",
+      "topics": []
+    },
     {
       "difficulty": 1,
       "slug": "word-count",

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

@@ -0,0 +1,15 @@
+unit module Luhn:ver<1>;
+
+sub is-luhn-valid ($input is copy) is export {
+  $input ~~ s:g/\s+//;
+  return False if $input.chars < 2 || $input ~~ /\D/;
+  my @num = $input.split('', :skip-empty);
+  @num.unshift: 0 if @num % 2;
+  my $sum;
+  for @num -> $a, $b {
+    $sum += $a * 2;
+    $sum -= 9 if $a * 2 > 9;
+    $sum += $b;
+  }
+  return ($sum %% 10).so;
+}

data/tracks/perl6/exercises/luhn/Luhn.pm6

@@ -0,0 +1,4 @@
+unit module Luhn:ver<1>;
+
+sub is-luhn-valid ($input) is export {
+}

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

@@ -0,0 +1,6 @@
+exercise: Luhn
+version: 1
+plan: 15
+imports: '&is-luhn-valid'
+tests: |
+  is .<input>.&is-luhn-valid, |.<expected description> for @($c-data<cases>);

data/tracks/perl6/exercises/luhn/luhn.t

@@ -0,0 +1,122 @@
+#!/usr/bin/env perl6
+use v6;
+use Test;
+use lib my $dir = $?FILE.IO.dirname;
+use JSON::Tiny;
+
+my $exercise = 'Luhn';
+my $version = v1;
+my $module = %*ENV<EXERCISM> ?? 'Example' !! $exercise;
+plan 15;
+
+use-ok $module or bail-out;
+require ::($module);
+
+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>;
+}
+
+require ::($module) <&is-luhn-valid>;
+
+my $c-data;
+is .<input>.&is-luhn-valid, |.<expected description> for @($c-data<cases>);
+
+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 }
+
+done-testing;
+
+INIT {
+$c-data := from-json q:to/END/;
+
+{
+  "exercise": "luhn",
+  "version": "1.0.0",
+  "cases": [
+    {
+      "description": "single digit strings can not be valid",
+      "property": "valid",
+      "input": "1",
+      "expected": false
+    },
+    {
+      "description": "A single zero is invalid",
+      "property": "valid",
+      "input": "0",
+      "expected": false
+    },
+    {
+      "description": "a simple valid SIN that remains valid if reversed",
+      "property": "valid",
+      "input": "059",
+      "expected": true
+    },
+    {
+      "description": "a simple valid SIN that becomes invalid if reversed",
+      "property": "valid",
+      "input": "59",
+      "expected": true
+    },
+    {
+      "description": "a valid Canadian SIN",
+      "property": "valid",
+      "input": "055 444 285",
+      "expected": true
+    },
+    {
+      "description": "invalid Canadian SIN",
+      "property": "valid",
+      "input": "055 444 286",
+      "expected": false
+    },
+    {
+      "description": "invalid credit card",
+      "property": "valid",
+      "input": "8273 1232 7352 0569",
+      "expected": false
+    },
+    {
+      "description": "valid strings with a non-digit included become invalid",
+      "property": "valid",
+      "input": "055a 444 285",
+      "expected": false
+    },
+    {
+      "description": "valid strings with punctuation included become invalid",
+      "property": "valid",
+      "input": "055-444-285",
+      "expected": false
+    },
+    {
+      "description": "valid strings with symbols included become invalid",
+      "property": "valid",
+      "input": "055£ 444$ 285",
+      "expected": false
+    },
+    {
+      "description": "single zero with space is invalid",
+      "property": "valid",
+      "input": " 0",
+      "expected": false
+    },
+    {
+      "description": "more than a single zero is valid",
+      "property": "valid",
+      "input": "0000 0",
+      "expected": true
+    },
+    {
+      "description": "input digit 9 is correctly converted to output digit 9",
+      "property": "valid",
+      "input": "091",
+      "expected": true
+    }
+  ]
+}
+
+END
+}

data/tracks/python/exercises/acronym/acronym_test.py

@@ -3,7 +3,7 @@ import unittest
 from acronym import abbreviate
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# test cases adapted from `x-common//canonical-data.json` @ version: 1.1.0
 
 class AcronymTest(unittest.TestCase):
     def test_basic(self):
@@ -12,9 +12,6 @@ class AcronymTest(unittest.TestCase):
     def test_lowercase_words(self):
         self.assertEqual(abbreviate('Ruby on Rails'), 'ROR')
 
-    def test_camelcase(self):
-        self.assertEqual(abbreviate('HyperText Markup Language'), 'HTML')
-
     def test_punctuation(self):
         self.assertEqual(abbreviate('First In, First Out'), 'FIFO')
 

data/tracks/r/exercises/hamming/test_hamming.R

@@ -2,86 +2,87 @@ source('./hamming.R')
 library(testthat)
 
 test_that("identical strands", {
-  strand1 <-"A"
+  strand1 <- "A"
   strand2 <- "A"
   expect_equal(hamming(strand1, strand2), 0)
 })
 
 test_that("long identical strands", {
-  strand1 <-"GGACTGA"
+  strand1 <- "GGACTGA"
   strand2 <- "GGACTGA"
   expect_equal(hamming(strand1, strand2), 0)
 })
 
 test_that("complete distance in single nucleotide strands", {
-  strand1 <-"A"
+  strand1 <- "A"
   strand2 <- "G"
   expect_equal(hamming(strand1, strand2), 1)
 })
 
 test_that("complete distance in small strands", {
-  strand1 <-"AG"
+  strand1 <- "AG"
   strand2 <- "CT"
   expect_equal(hamming(strand1, strand2), 2)
 })
 
 test_that("small distance in small strands", {
-  strand1 <-"AT"
+  strand1 <- "AT"
   strand2 <- "CT"
   expect_equal(hamming(strand1, strand2), 1)
 })
 
 test_that("small distance", {
-  strand1 <-"GGACG"
+  strand1 <- "GGACG"
   strand2 <- "GGTCG"
   expect_equal(hamming(strand1, strand2), 1)
 })
 
 test_that("small distance in long strands", {
-  strand1 <-"ACCAGGG"
+  strand1 <- "ACCAGGG"
   strand2 <- "ACTATGG"
   expect_equal(hamming(strand1, strand2), 2)
 })
 
 test_that("non-unique character in first strand", {
-  strand1 <-"AGA"
+  strand1 <- "AGA"
   strand2 <- "AGG"
   expect_equal(hamming(strand1, strand2), 1)
 })
 
 test_that("non-unique character in second strand", {
-  strand1 <-"AGG"
+  strand1 <- "AGG"
   strand2 <- "AGA"
   expect_equal(hamming(strand1, strand2), 1)
 })
 
 test_that("same nucleotides in different positions", {
-  strand1 <-"TAG"
+  strand1 <- "TAG"
   strand2 <- "GAT"
   expect_equal(hamming(strand1, strand2), 2)
 })
 
 test_that("large distance", {
-  strand1 <-"GATACA"
+  strand1 <- "GATACA"
   strand2 <- "GCATAA"
   expect_equal(hamming(strand1, strand2), 4)
 })
 
 test_that("empty strands", {
-  strand1 <-""
+  strand1 <- ""
   strand2 <- ""
   expect_equal(hamming(strand1, strand2), 0)
 })
 
 test_that("disallow first strand longer", {
-  strand1 <-"AATG"
+  strand1 <- "AATG"
   strand2 <- "AAA"
   expect_error(hamming(strand1, strand2))
 })
 
 test_that("disallow second strand longer", {
-  strand1 <-"ATA"
+  strand1 <- "ATA"
   strand2 <- "AGTG"
   expect_error(hamming(strand1, strand2))
 })
 
+print("All tests passed!")

data/tracks/ruby/lib/generator/command_line/generator_optparser.rb

@@ -83,7 +83,9 @@ module Generator
 
     def validate_cases
       return true if available_generators.include?(options[:slug])
-      $stderr.puts "A generator does not currently exist for #{options[:slug]}!"
+      warning = "A generator does not currently exist for #{options[:slug]}!"
+      expected_location = "Expecting it to be at: #{Files::GeneratorCases.source_filepath(@paths.track, options[:slug])}"
+      $stderr.puts [warning, expected_location].join("\n")
       false
     end
   end

data/tracks/ruby/lib/generator/exercise_case/assertion.rb

@@ -1,31 +1,59 @@
 module Generator
-  class ExerciseCase < OpenStruct
+  class ExerciseCase
     module Assertion
 
+      # generates assertions of the form
+      #
+      #   assert whatever
+      #   refute whatever
+      #
+      # depending on whether 'expected' is true or false
+      #
+      # call as
+      #
       #  "#{assert} Luhn.valid?(#{input.inspect})"
+      #
       def assert
         expected ? 'assert' : 'refute'
       end
 
-      # e.g.,
+      # generates assertions of the form
+      #
+      #   assert_nil whatever
+      #   assert_equal expected, whatever
+      #
+      # depending on whether 'expected' is nil or not
+      #
+      # call as
+      #
       #   assert_equal { "PigLatin.translate(#{input.inspect})" }
+      #
       def assert_equal
-        assertion = expected.nil? ? 'assert_nil' : "assert_equal #{expected.inspect},"
+        assertion = expected.nil? ? 'assert_nil' :
+                      "assert_equal #{expected.inspect},"
         "#{assertion} #{yield}"
       end
 
-      # e.g.,
+      # a helper function, used to build statements such as
+      #
       #   if raises_error?
       #     assert_raises(ArgumentError) { test_case }
       #   else
       #     assert_equal { test_case }
       #   end
+      #
       def raises_error?
         expected.to_i == -1
       end
 
-      # e.g.,
+      # generates assertions of the form
+      #
+      #   assert_raises(SomeError) { whatever }
+      #
+      # call as
+      #
       #   assert_raises(ArgumentError) { test_case }
+      #
       def assert_raises(error)
         "assert_raises(#{error}) { #{yield} }"
       end

data/tracks/ruby/lib/generator/exercise_case/case_helpers.rb

@@ -0,0 +1,39 @@
+module Generator
+  class ExerciseCase
+    module CaseHelpers
+      protected
+
+      # indent multi line workloads
+      #
+      #   indent_lines(
+      #     [
+      #       "string = #{input.inspect}",
+      #       "#{assert} Isogram.is_isogram?(string)"
+      #     ], 4
+      #   )
+      def indent_lines(code, depth, separator = "\n")
+        code.join(separator + ' ' * depth)
+      end
+
+      # indent multi line workloads with (unindented) blank lines
+      #
+      #   indent_text(4, text)
+      def indent_text(depth, text)
+        text.lines.reduce do |obj, line|
+          obj << (line == "\n" ? line : ' ' * depth + line)
+        end
+      end
+
+      # generate heredoc (as part of workload) with optional indentation
+      #
+      #    indent_heredoc(["foo", "bar"], 'TEXT', 1)
+      def indent_heredoc(lines, delimiter, depth = 0, delimiter_method = nil)
+        [
+          "<<-#{delimiter}#{delimiter_method}",
+          lines.map { |line| ' ' * depth + line }.join("\n"),
+          delimiter
+        ].join("\n")
+      end
+    end
+  end
+end

data/tracks/ruby/lib/generator/exercise_case.rb

@@ -1,51 +1,17 @@
 require 'ostruct'
-require 'json'
 
 module Generator
   class ExerciseCase < OpenStruct
     using Generator::Underscore
+    include CaseHelpers
     include Assertion
 
     def name
       'test_%s' % description.underscore
     end
 
-    def skipped(idx)
-      idx.zero? ? '# skip' : 'skip'
-    end
-
-    protected
-
-    # indent multi line workloads
-    #
-    #   indent_lines(
-    #     [
-    #       "string = #{input.inspect}",
-    #       "#{assert} Isogram.is_isogram?(string)"
-    #     ], 4
-    #   )
-    def indent_lines(code, depth, separator = "\n")
-      code.join(separator + ' ' * depth)
-    end
-
-    # indent multi line workloads with (unindented) blank lines
-    #
-    #   indent_text(4, text)
-    def indent_text(depth, text)
-      text.lines.reduce do |obj, line|
-        obj << (line == "\n" ? line : ' ' * depth + line)
-      end
-    end
-
-    # generate heredoc (as part of workload) with optional indentation
-    #
-    #    indent_heredoc(["foo", "bar"], 'TEXT', 1)
-    def indent_heredoc(lines, delimiter, depth = 0, delimiter_method = nil)
-      [
-        "<<-#{delimiter}#{delimiter_method}",
-        lines.map { |line| ' ' * depth + line }.join("\n"),
-        delimiter
-      ].join("\n")
+    def skipped(index)
+      index.zero? ? '# skip' : 'skip'
     end
   end
 end

data/tracks/ruby/lib/generator/template_values.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module Generator
   # Contains methods accessible to the ERB template
   class TemplateValues

data/tracks/ruby/test/generator/command_line/generator_optparser_test.rb

@@ -111,9 +111,18 @@ module Generator
     end
 
     def test_validate_missing_generator
-      args = %w(nonexistent)
+      args = %w(non-existent)
       Files::GeneratorCases.stub :available, [] do
-        assert_output(nil, /A generator does not currently exist fo/) do
+        assert_output(nil, /A generator does not currently exist for non-existent/) do
+          refute GeneratorOptparser.new(args, FixturePaths).options_valid?
+        end
+      end
+    end
+
+    def test_missing_generator_tells_you_where_it_looked
+      args = %w(non-existent)
+      Files::GeneratorCases.stub :available, [] do
+        assert_output(nil, %r{exercises/non-existent/\.meta/generator/non_existent_case\.rb}) do
           refute GeneratorOptparser.new(args, FixturePaths).options_valid?
         end
       end

data/tracks/ruby/test/generator/exercise_case/case_helpers_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../test_helper'
+
+module Generator
+  class ExerciseCase
+    class CaseHelpersTest < Minitest::Test
+      class MultiLineCase
+        include CaseHelpers
+
+        def workload
+          indent_lines(['foo', 'bar'], 1)
+        end
+      end
+      def test_indent_multiline_workloads
+        expected = "foo\n bar"
+        assert_equal expected, MultiLineCase.new.workload
+      end
+
+      class BlankLineCase
+        include CaseHelpers
+
+        def workload
+          indent_text(2, "foo\n\nbar\n")
+        end
+      end
+      def test_indent_multiline_workloads_with_blank_lines
+        expected = "foo\n\n  bar\n"
+        assert_equal expected, BlankLineCase.new.workload
+      end
+
+      class HeredocCase
+        include CaseHelpers
+
+        def workload
+          indent_heredoc(["foo", "bar"], 'TEXT', 1)
+        end
+      end
+      def test_heredoc
+        expected = "<<-TEXT\n foo\n bar\nTEXT"
+        assert_equal expected, HeredocCase.new.workload
+      end
+    end
+  end
+end

data/tracks/ruby/test/generator/underscore_test.rb

@@ -19,5 +19,9 @@ module Generator
         'unreadable_but_correctly_sized_inputs_return_?'
       )
     end
+
+    def test_fixnum_underscore
+      assert_equal '1_000_000', 1000000.underscore
+    end
   end
 end

data/tracks/scala/config.json

@@ -245,6 +245,16 @@
             "Sequences"
          ]
       },
+      {
+        "slug": "beer-song",
+        "difficulty": 3,
+        "topics": [
+          "Text formatting",
+          "Algorithms",
+          "Control-flow",
+          "Strings"
+        ]
+      },      
       {
          "slug":"matrix",
          "difficulty":4,

data/tracks/scala/exercises/beer-song/build.sbt

@@ -0,0 +1,3 @@
+name := "beer-song"
+scalaVersion := "2.12.2"
+libraryDependencies += "org.scalatest" %% "scalatest" % "3.0.1" % "test"

data/tracks/scala/exercises/beer-song/example.scala

@@ -0,0 +1,11 @@
+object Example {
+  def verses(upper: Int, lower: Int): String =
+    upper to lower by -1 map verse mkString "\n"
+
+  def verse(n: Int): String = n match {
+    case 0 => "No more bottles of beer on the wall, no more bottles of beer.\nGo to the store and buy some more, 99 bottles of beer on the wall.\n"
+    case 1 => "1 bottle of beer on the wall, 1 bottle of beer.\nTake it down and pass it around, no more bottles of beer on the wall.\n"
+    case 2 => "2 bottles of beer on the wall, 2 bottles of beer.\nTake one down and pass it around, 1 bottle of beer on the wall.\n"
+    case _ => s"$n bottles of beer on the wall, $n bottles of beer.\nTake one down and pass it around, ${n - 1} bottles of beer on the wall.\n"
+  }
+}