trackler 2.1.0.24 → 2.1.0.25

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

@@ -4,43 +4,43 @@ module Generator
   class ExerciseCase
     class AssertionTest < Minitest::Test
       def test_assert
-        test_case = OpenStruct.new(expected: true)
+        test_case = ExerciseCase.new(canonical: OpenStruct.new({'expected' => true}))
         test_case.extend(Assertion)
         assert_equal 'assert', test_case.assert
       end
 
       def test_refute
-        test_case = OpenStruct.new(expected: false)
+        test_case = ExerciseCase.new(canonical: OpenStruct.new({'expected' => false}))
         test_case.extend(Assertion)
         assert_equal 'refute', test_case.assert
       end
 
       def test_assert_equal
-        test_case = OpenStruct.new(expected: 2)
+        test_case = ExerciseCase.new(canonical: OpenStruct.new({'expected' => 2}))
         test_case.extend(Assertion)
         assert_equal "assert_equal 2, 4", test_case.assert_equal { 1 + 3 }
       end
 
       def test_assert_equal_when_nil
-        test_case = OpenStruct.new(expected: nil)
+        test_case = ExerciseCase.new(canonical: OpenStruct.new({'expected' => nil}))
         test_case.extend(Assertion)
         assert_equal "assert_nil 4", test_case.assert_equal { 1 + 3 }
       end
 
       def test_raises_error
-        test_case = OpenStruct.new(expected: -1)
+        test_case = ExerciseCase.new(canonical: OpenStruct.new({'expected' => -1}))
         test_case.extend(Assertion)
         assert test_case.raises_error?
       end
 
       def test_does_not_raise_error
-        test_case = OpenStruct.new(expected: 'cute kitties')
+        test_case = ExerciseCase.new(canonical: OpenStruct.new({'expected' => 'cute kitties'}))
         test_case.extend(Assertion)
         refute test_case.raises_error?
       end
 
       def test_assert_raises
-        test_case = OpenStruct.new
+        test_case = ExerciseCase.new(canonical: OpenStruct.new({}))
         test_case.extend(Assertion)
         assert_equal(
           "assert_raises(ArgumentError) { 4 }",

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

@@ -3,45 +3,41 @@ require_relative '../test_helper'
 module Generator
   class ExerciseCaseTest < Minitest::Test
     def test_name
-      assert_equal 'test_foo', ExerciseCase.new(description: 'foo').name
+      subject = ExerciseCase.new(canonical: OpenStruct.new(description: 'foo'))
+      assert_equal 'test_foo', subject.name
     end
 
     def test_skipped_index_zero
-      assert_equal '# skip', ExerciseCase.new.skipped(0)
+      assert_equal '# skip', ExerciseCase.new(canonical: nil).skipped(0)
     end
 
     def test_skipped_index_nonzero
-      assert_equal 'skip', ExerciseCase.new.skipped(1)
+      assert_equal 'skip', ExerciseCase.new(canonical: nil).skipped(1)
     end
 
-    class MultiLineCase < ExerciseCase
-      def workload
-        indent_lines(['foo', 'bar'], 1)
-      end
-    end
-    def test_indent_multiline_workloads
-      expected = "foo\n bar"
-      assert_equal expected, MultiLineCase.new.workload
+    def test_forwarding_to_canonical
+      mock_canonical = Minitest::Mock.new
+      mock_canonical.expect :key, 'fake value'
+      subject = ExerciseCase.new(canonical: mock_canonical)
+      subject.key
+      mock_canonical.verify
     end
 
-    class BlankLineCase < ExerciseCase
-      def workload
-        indent_text(2, "foo\n\nbar\n")
+    def test_method_mising_calls_super
+      subject = ExerciseCase.new(canonical: nil)
+      assert_raises NoMethodError do
+        subject.key
       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 < ExerciseCase
-      def workload
-        indent_heredoc(["foo", "bar"], 'TEXT', 1)
-      end
+    def test_true_respond_to?
+      subject = ExerciseCase.new(canonical: OpenStruct.new(key: 'value'))
+      assert subject.respond_to?(:key)
     end
-    def test_heredoc
-      expected = "<<-TEXT\n foo\n bar\nTEXT"
-      assert_equal expected, HeredocCase.new.workload
+
+    def test_false_respond_to?
+      subject = ExerciseCase.new(canonical: OpenStruct.new())
+      refute subject.respond_to?(:key)
     end
   end
 end

data/tracks/ruby/test/wordy_cases_test.rb

@@ -4,7 +4,7 @@ require_relative '../exercises/wordy/.meta/generator/wordy_case'
 
 class WordyCaseTest < Minitest::Test
   def test_workload_with_expected_and_no_message
-    test_case = WordyCase.new(expected: 1, input: 1)
+    test_case = WordyCase.new(canonical: OpenStruct.new(expected: 1, input: 1))
 
     expected_workload = [
       'question = \'1\'',
@@ -15,7 +15,7 @@ class WordyCaseTest < Minitest::Test
   end
 
   def test_workload_with_expected_and_message
-    test_case = WordyCase.new(expected: 1, input: 'What is -3 plus 7 multiplied by -2?')
+    test_case = WordyCase.new(canonical: OpenStruct.new(expected: 1, input: 'What is -3 plus 7 multiplied by -2?'))
     message = test_case.send(:message)
 
     expected_workload = [
@@ -28,8 +28,8 @@ class WordyCaseTest < Minitest::Test
     assert_equal expected_workload, test_case.workload
   end
 
-  def test_workload_without_expected
-    test_case = WordyCase.new(input: 1)
+  def test_workload_with_expected_false
+    test_case = WordyCase.new(canonical: OpenStruct.new(input: 1, expected: false))
 
     expected_workload = [
       'question = \'1\'',

data/tracks/rust/LICENSE

@@ -1,6 +1,6 @@
-The MIT License (MIT)
+MIT License
 
-Copyright (c) 2014 Katrina Owen, _@kytrinyx.com
+Copyright (c) 2017 Exercism, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/tracks/rust/README.md

@@ -9,11 +9,6 @@ Exercism exercises in Rust
 
 Please see the [contributing guide](https://github.com/exercism/x-common/blob/master/CONTRIBUTING.md)
 
-## License
-
-The MIT License (MIT)
-
-Copyright (c) 2014 Katrina Owen, _@kytrinyx.com
 
 ## Rust icon
 The Rust Logo is created by the Mozilla Corporation, and has been released under the [Creative Commons Attribution 4.0 International license](https://creativecommons.org/licenses/by/4.0/).

data/tracks/rust/config.json

@@ -213,6 +213,7 @@
       "slug": "rna-transcription",
       "difficulty": 4,
       "topics": [
+        "Result",
         "match",
         "struct",
         "str vs string"

data/tracks/rust/exercises/etl/Cargo.toml

@@ -1,3 +1,3 @@
 [package]
 name = "etl"
-version = "0.0.0"
+version = "1.0.0"

data/tracks/rust/exercises/etl/example.rs

@@ -1,8 +1,8 @@
 use std::ascii::AsciiExt;
 use std::collections::BTreeMap;
 
-pub fn transform(input: &BTreeMap<i32, Vec<String>>) -> BTreeMap<String, i32> {
+pub fn transform(input: &BTreeMap<i32, Vec<char>>) -> BTreeMap<char, i32> {
     input.iter().flat_map(|(&n, vec)| {
-        vec.iter().map(move |s| (s.to_ascii_lowercase(), n))
+        vec.iter().map(move |c| (c.to_ascii_lowercase(), n))
     }).collect()
 }

data/tracks/rust/exercises/etl/tests/etl.rs

@@ -5,11 +5,11 @@ use std::collections::BTreeMap;
 #[test]
 fn test_transform_one_value() {
     let input = input_from(&[
-        (1, vec!("WORLD")),
+        (1, vec!('A')),
     ]);
 
     let expected = expected_from(&[
-        ("world", 1),
+        ('a', 1),
     ]);
 
     assert_eq!(expected, etl::transform(&input));
@@ -19,11 +19,11 @@ fn test_transform_one_value() {
 #[ignore]
 fn test_transform_more_values() {
     let input = input_from(&[
-        (1, vec!("WORLD", "GSCHOOLERS")),
+        (1, vec!('A', 'E', 'I', 'O', 'U')),
     ]);
 
     let expected = expected_from(&[
-        ("world", 1), ("gschoolers", 1),
+        ('a', 1), ('e', 1), ('i', 1), ('o', 1), ('u', 1),
     ]);
 
     assert_eq!(expected, etl::transform(&input));
@@ -33,13 +33,13 @@ fn test_transform_more_values() {
 #[ignore]
 fn test_more_keys() {
     let input = input_from(&[
-        (1, vec!("APPLE", "ARTICHOKE")),
-        (2, vec!("BOAT", "BALLERINA")),
+        (1, vec!('A', 'E')),
+        (2, vec!('D', 'G')),
     ]);
 
     let expected = expected_from(&[
-        ("apple", 1), ("artichoke", 1),
-        ("boat",  2), ("ballerina", 2),
+        ('a', 1), ('e', 1),
+        ('d',  2), ('g', 2),
     ]);
 
     assert_eq!(expected, etl::transform(&input));
@@ -49,38 +49,32 @@ fn test_more_keys() {
 #[ignore]
 fn test_full_dataset() {
     let input = input_from(&[
-        (1,  vec!("A", "E", "I", "O", "U", "L", "N", "R", "S", "T")),
-        (2,  vec!("D", "G")),
-        (3,  vec!("B", "C", "M", "P")),
-        (4,  vec!("F", "H", "V", "W", "Y")),
-        (5,  vec!("K")),
-        (8,  vec!("J", "X")),
-        (10, vec!("Q", "Z")),
+        (1,  vec!('A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T')),
+        (2,  vec!('D', 'G')),
+        (3,  vec!('B', 'C', 'M', 'P')),
+        (4,  vec!('F', 'H', 'V', 'W', 'Y')),
+        (5,  vec!('K')),
+        (8,  vec!('J', 'X')),
+        (10, vec!('Q', 'Z')),
     ]);
 
     let expected = expected_from(&[
-        ("a",  1), ("b",  3), ("c",  3), ("d",  2),
-        ("e",  1), ("f",  4), ("g",  2), ("h",  4),
-        ("i",  1), ("j",  8), ("k",  5), ("l",  1),
-        ("m",  3), ("n",  1), ("o",  1), ("p",  3),
-        ("q", 10), ("r",  1), ("s",  1), ("t",  1),
-        ("u",  1), ("v",  4), ("w",  4), ("x",  8),
-        ("y",  4), ("z", 10),
+        ('a',  1), ('b',  3), ('c',  3), ('d',  2),
+        ('e',  1), ('f',  4), ('g',  2), ('h',  4),
+        ('i',  1), ('j',  8), ('k',  5), ('l',  1),
+        ('m',  3), ('n',  1), ('o',  1), ('p',  3),
+        ('q', 10), ('r',  1), ('s',  1), ('t',  1),
+        ('u',  1), ('v',  4), ('w',  4), ('x',  8),
+        ('y',  4), ('z', 10),
     ]);
 
     assert_eq!(expected, etl::transform(&input));
 }
 
-fn input_from(v: &[(i32, Vec<&str>)]) -> BTreeMap<i32, Vec<String>> {
-    v.iter().fold(BTreeMap::new(), |mut acc, &(n, ref v)| {
-        acc.insert(n, v.iter().map(|s| s.to_string()).collect());
-        acc
-    })
+fn input_from(v: &[(i32, Vec<char>)]) -> BTreeMap<i32, Vec<char>> {
+    v.iter().cloned().collect()
 }
 
-fn expected_from(v: &[(&str, i32)]) -> BTreeMap<String, i32> {
-    v.iter().fold(BTreeMap::new(), |mut acc, &(s, n)| {
-        acc.insert(s.to_string(), n);
-        acc
-    })
+fn expected_from(v: &[(char, i32)]) -> BTreeMap<char, i32> {
+    v.iter().cloned().collect()
 }

data/tracks/rust/exercises/forth/tests/forth.rs

@@ -1,5 +1,3 @@
-#![allow(unused_must_use)]
-
 extern crate forth;
 
 use forth::{Forth, Error};
@@ -13,7 +11,7 @@ fn no_input_no_stack() {
 #[ignore]
 fn numbers_just_get_pushed_onto_the_stack() {
     let mut f = Forth::new();
-    f.eval("1 2 3 4 5 -1");
+    assert!(f.eval("1 2 3 4 5 -1").is_ok());
     assert_eq!("1 2 3 4 5 -1", f.format_stack());
 }
 
@@ -22,7 +20,7 @@ fn numbers_just_get_pushed_onto_the_stack() {
 fn non_word_characters_are_separators() {
     let mut f = Forth::new();
     // Note the Ogham Space Mark ( ), this is a spacing character.
-    f.eval("1\u{0000}2\u{0001}3\n4\r5 6\t7");
+    assert!(f.eval("1\u{0000}2\u{0001}3\n4\r5 6\t7").is_ok());
     assert_eq!("1 2 3 4 5 6 7", f.format_stack());
 }
 
@@ -30,7 +28,7 @@ fn non_word_characters_are_separators() {
 #[ignore]
 fn basic_arithmetic_1() {
     let mut f = Forth::new();
-    f.eval("1 2 + 4 -");
+    assert!(f.eval("1 2 + 4 -").is_ok());
     assert_eq!("-1", f.format_stack());
 }
 
@@ -38,7 +36,7 @@ fn basic_arithmetic_1() {
 #[ignore]
 fn basic_arithmetic_2() {
     let mut f = Forth::new();
-    f.eval("2 4 * 3 /");
+    assert!(f.eval("2 4 * 3 /").is_ok());
     assert_eq!("2", f.format_stack());
 }
 
@@ -96,7 +94,7 @@ fn division_by_zero() {
 #[ignore]
 fn dup() {
     let mut f = Forth::new();
-    f.eval("1 DUP");
+    assert!(f.eval("1 DUP").is_ok());
     assert_eq!("1 1", f.format_stack());
 }
 
@@ -104,7 +102,7 @@ fn dup() {
 #[ignore]
 fn dup_case_insensitive() {
     let mut f = Forth::new();
-    f.eval("1 Dup");
+    assert!(f.eval("1 Dup").is_ok());
     assert_eq!("1 1", f.format_stack());
 }
 
@@ -122,7 +120,7 @@ fn dup_error() {
 #[ignore]
 fn drop() {
     let mut f = Forth::new();
-    f.eval("1 drop");
+    assert!(f.eval("1 drop").is_ok());
     assert_eq!("", f.format_stack());
 }
 
@@ -130,7 +128,7 @@ fn drop() {
 #[ignore]
 fn drop_with_two() {
     let mut f = Forth::new();
-    f.eval("1 2 drop");
+    assert!(f.eval("1 2 drop").is_ok());
     assert_eq!("1", f.format_stack());
 }
 
@@ -148,7 +146,7 @@ fn drop_error() {
 #[ignore]
 fn swap() {
     let mut f = Forth::new();
-    f.eval("1 2 swap");
+    assert!(f.eval("1 2 swap").is_ok());
     assert_eq!("2 1", f.format_stack());
 }
 
@@ -156,7 +154,7 @@ fn swap() {
 #[ignore]
 fn swap_with_three() {
     let mut f = Forth::new();
-    f.eval("1 2 3 swap");
+    assert!(f.eval("1 2 3 swap").is_ok());
     assert_eq!("1 3 2", f.format_stack());
 }
 
@@ -178,7 +176,7 @@ fn swap_error() {
 #[ignore]
 fn over() {
     let mut f = Forth::new();
-    f.eval("1 2 over");
+    assert!(f.eval("1 2 over").is_ok());
     assert_eq!("1 2 1", f.format_stack());
 }
 
@@ -186,7 +184,7 @@ fn over() {
 #[ignore]
 fn over_with_three() {
     let mut f = Forth::new();
-    f.eval("1 2 3 over");
+    assert!(f.eval("1 2 3 over").is_ok());
     assert_eq!("1 2 3 2", f.format_stack());
 }
 
@@ -208,8 +206,8 @@ fn over_error() {
 #[ignore]
 fn defining_a_new_word() {
     let mut f = Forth::new();
-    f.eval(": CoUnT 1 2 3 ;");
-    f.eval("count COUNT");
+    assert!(f.eval(": CoUnT 1 2 3 ;").is_ok());
+    assert!(f.eval("count COUNT").is_ok());
     assert_eq!("1 2 3 1 2 3", f.format_stack());
 }
 
@@ -217,9 +215,9 @@ fn defining_a_new_word() {
 #[ignore]
 fn redefining_an_existing_word() {
     let mut f = Forth::new();
-    f.eval(": foo dup ;");
-    f.eval(": foo dup dup ;");
-    f.eval("1 foo");
+    assert!(f.eval(": foo dup ;").is_ok());
+    assert!(f.eval(": foo dup dup ;").is_ok());
+    assert!(f.eval("1 foo").is_ok());
     assert_eq!("1 1 1", f.format_stack());
 }
 
@@ -227,8 +225,8 @@ fn redefining_an_existing_word() {
 #[ignore]
 fn redefining_an_existing_built_in_word() {
     let mut f = Forth::new();
-    f.eval(": swap dup ;");
-    f.eval("1 swap");
+    assert!(f.eval(": swap dup ;").is_ok());
+    assert!(f.eval("1 swap").is_ok());
     assert_eq!("1 1", f.format_stack());
 }
 
@@ -236,7 +234,7 @@ fn redefining_an_existing_built_in_word() {
 #[ignore]
 fn defining_words_with_odd_characters() {
     let mut f = Forth::new();
-    f.eval(": € 220371 ; €");
+    assert!(f.eval(": € 220371 ; €").is_ok());
     assert_eq!("220371", f.format_stack());
 }