trackler 2.1.0.1 → 2.1.0.2

data/tracks/go/exercises/raindrops/example.go

@@ -2,7 +2,7 @@ package raindrops
 
 import "strconv"
 
-const testVersion = 2
+const testVersion = 3
 
 func Convert(number int) string {
 	s := ""

data/tracks/go/exercises/raindrops/raindrops.go

@@ -1,6 +1,6 @@
 package raindrops
 
-const testVersion = 2
+const testVersion = 3
 
 func Convert(int) string
 

data/tracks/go/exercises/raindrops/raindrops_test.go

@@ -2,7 +2,7 @@ package raindrops
 
 import "testing"
 
-const targetTestVersion = 2
+const targetTestVersion = 3
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {

data/tracks/java/config.json

@@ -105,6 +105,11 @@
       "difficulty": 4,
       "topics": []
     },
+    {
+      "slug": "isogram",
+      "difficulty": 4,
+      "topics": []
+    },
     {
       "slug": "flatten-array",
       "difficulty": 5,
@@ -314,11 +319,6 @@
       "slug": "ocr-numbers",
       "difficulty": 1,
       "topics": []
-    },
-     {
-      "slug": "isogram",
-      "difficulty": 1,
-      "topics": []
     },
     {
       "slug": "book-store",

data/tracks/java/exercises/isogram/src/example/java/IsogramChecker.java

@@ -1,34 +1,30 @@
-package example;
-
 import java.util.HashSet;
 import java.util.Set;
+
 import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.joining;
 
 public class IsogramChecker {
-	
-	public IsogramChecker(){
-	}
-	
-	public boolean isIsogram(String word){
-		
-		Set<Character> charSet = new HashSet<>();
-		
-		String[] words = word.split(" ");
-		String newWord = concat(words);
-		
-		words = newWord.split("-");
-		newWord = concat(words).toLowerCase();
-		
-		for(int i = 0; i < newWord.length(); i++){
-			charSet.add(newWord.charAt(i));
-		}
-		
-		return charSet.size() == newWord.length();
-	}
-	
-	private String concat(String[] words){
-		return stream(words).collect(joining());
-	}
-	
+
+    public boolean isIsogram(String word) {
+
+        Set<Character> charSet = new HashSet<>();
+
+        String[] words = word.split(" ");
+        String newWord = concat(words);
+
+        words = newWord.split("-");
+        newWord = concat(words).toLowerCase();
+
+        for (int i = 0; i < newWord.length(); i++) {
+            charSet.add(newWord.charAt(i));
+        }
+
+        return charSet.size() == newWord.length();
+    }
+
+    private String concat(String[] words) {
+        return stream(words).collect(joining());
+    }
+
 }

data/tracks/java/exercises/isogram/src/test/java/IsogramCheckerTest.java

@@ -0,0 +1,77 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class IsogramCheckerTest {
+
+    @Test
+    public void testIsogram() {
+        IsogramChecker iso = new IsogramChecker();
+        assertTrue(iso.isIsogram("duplicates"));
+    }
+
+    @Ignore
+    @Test
+    public void testNotIsogram() {
+        IsogramChecker iso = new IsogramChecker();
+        assertFalse(iso.isIsogram("eleven"));
+    }
+
+    @Ignore
+    @Test
+    public void testMediumLongIsogram() {
+        IsogramChecker iso = new IsogramChecker();
+        assertTrue(iso.isIsogram("subdermatoglyphic"));
+    }
+
+    @Ignore
+    @Test
+    public void testCaseInsensitive() {
+        IsogramChecker iso = new IsogramChecker();
+        assertFalse(iso.isIsogram("Alphabet"));
+    }
+
+    @Ignore
+    @Test
+    public void testIsogramWithHyphen() {
+        IsogramChecker iso = new IsogramChecker();
+        assertTrue(iso.isIsogram("thumbscrew-japingly"));
+    }
+
+    @Ignore
+    @Test
+    public void testIgnoresMultipleHyphens() {
+        IsogramChecker iso = new IsogramChecker();
+        assertTrue(iso.isIsogram("Hjelmqvist-Gryb-Zock-Pfund-Wax"));
+    }
+
+    @Ignore
+    @Test
+    public void testWorksWithGermanLetters() {
+        IsogramChecker iso = new IsogramChecker();
+        assertTrue(iso.isIsogram("Heizölrückstoßabdämpfung"));
+    }
+
+    @Ignore
+    @Test
+    public void testIgnoresSpaces() {
+        IsogramChecker iso = new IsogramChecker();
+        assertFalse(iso.isIsogram("the quick brown fox"));
+    }
+
+    @Ignore
+    @Test
+    public void testIgnoresSpaces2() {
+        IsogramChecker iso = new IsogramChecker();
+        assertTrue(iso.isIsogram("Emily Jung Schwartzkopf"));
+    }
+
+    @Ignore
+    @Test
+    public void testDuplicateAccentedLetters() {
+        IsogramChecker iso = new IsogramChecker();
+        assertFalse(iso.isIsogram("éléphant"));
+    }
+
+}

data/tracks/javascript/config.json

@@ -48,6 +48,7 @@
     "series",
     "difference-of-squares",
     "secret-handshake",
+    "proverb",
     "linked-list",
     "wordy",
     "flatten-array",
@@ -352,6 +353,14 @@
       "topics": [
       ]
     },
+    {
+      "slug": "proverb",
+      "difficulty": 1,
+      "topics": [
+        "Arrays",
+        "Optional values"
+      ]
+    },
     {
       "slug": "linked-list",
       "difficulty": 1,

data/tracks/javascript/exercises/proverb/example.js

@@ -0,0 +1,36 @@
+module.exports = function(){
+  var last = arguments[arguments.length - 1];
+  var chain = Array.from(arguments);
+  this.options = {};
+
+  if(typeof last == "object" && last.hasOwnProperty("qualifier")){
+    this.options = chain.pop();
+  }
+
+  this.chain = chain;
+  this.qualifier = this.options.qualifier ? this.options.qualifier + ' ' : '';
+
+  this.toString = function(){
+    return this.chainOfEvents() + this.conclusion();
+  }.bind(this);
+
+  this.chainOfEvents = function(){
+    return this.causesAndEffects().map( function(entry){
+      return "For want of a " + entry.cause +
+        " the "  + entry.effect + " was lost.\n";
+    }.bind(this) ).join('');
+  }.bind(this);
+
+  this.causesAndEffects = function(){
+     return this.chain.reduce( function(array, event, index){
+      if(index < this.chain.length - 1){
+        array.push({ cause: event, effect: this.chain[index + 1] });
+      }
+      return array;
+    }.bind(this), [] );
+  }.bind(this);
+
+  this.conclusion = function(){
+    return "And all for the want of a " + this.qualifier + this.chain[0] + ".";
+  }.bind(this);
+};

data/tracks/javascript/exercises/proverb/proverb.spec.js

@@ -0,0 +1,78 @@
+var Proverb = require('./proverb');
+
+describe('Proverb Test Suite', function() {
+  it('tests a single consequence', function() {
+    var proverb = new Proverb('nail', 'shoe');
+
+    expect(proverb.toString()).toEqual(
+      "For want of a nail the shoe was lost.\n" +
+      "And all for the want of a nail.");
+  });
+
+  
+  it('tests a short chain of consequences', function() {
+    var proverb = new Proverb('nail', 'shoe', 'horse');
+
+    expect(proverb.toString()).toEqual(
+      "For want of a nail the shoe was lost.\n" +
+      "For want of a shoe the horse was lost.\n" +
+      "And all for the want of a nail.");
+  });
+
+  it('tests a longer chain of consequences', function() {
+    var proverb = new Proverb('nail', 'shoe', 'horse', 'rider');
+
+    expect(proverb.toString()).toEqual(
+     "For want of a nail the shoe was lost.\n" +
+     "For want of a shoe the horse was lost.\n" +
+     "For want of a horse the rider was lost.\n" +
+     "And all for the want of a nail.");
+  });
+
+
+  it('tests Proverb class does not hard code the rhyme dictionary', 
+      function() {
+    var proverb = new Proverb('key', 'value');
+
+    expect(proverb.toString()).toEqual(
+      "For want of a key the value was lost.\n" +
+      "And all for the want of a key.");
+  });
+
+  it('tests the whole proveb', function() {
+    var proverb = new Proverb('nail', 'shoe', 'horse', 'rider', 
+                              'message', 'battle', 'kingdom');
+
+    expect(proverb.toString()).toEqual(
+      "For want of a nail the shoe was lost.\n" +
+      "For want of a shoe the horse was lost.\n" +
+      "For want of a horse the rider was lost.\n" +
+      "For want of a rider the message was lost.\n" +
+      "For want of a message the battle was lost.\n" +
+      "For want of a battle the kingdom was lost.\n" +
+      "And all for the want of a nail.");
+  });
+
+
+  it('tests the use of an optional qualifier in the final consequence', 
+      function() {
+    var proverb = new Proverb('nail', 'shoe', 'horse', 'rider', 
+                              'message', 'battle', 'kingdom', 
+                              { qualifier: 'horseshoe' });
+
+    expect(proverb.toString()).toEqual(
+     "For want of a nail the shoe was lost.\n" +
+     "For want of a shoe the horse was lost.\n" +
+     "For want of a horse the rider was lost.\n" +
+     "For want of a rider the message was lost.\n" +
+     "For want of a message the battle was lost.\n" +
+     "For want of a battle the kingdom was lost.\n" +
+     "And all for the want of a horseshoe nail.");
+  });
+
+  it('tests the proverb is the same each time', function(){
+    var proverb = new Proverb('nail', 'shoe');
+
+    expect(proverb.toString()).toEqual(proverb.toString());
+  });
+});

data/tracks/ruby/README.md

@@ -157,39 +157,6 @@ and any setup required. The base class provides a variety of assertion and
 helper methods. Beyond that, you can implement any helper methods that you need
 as private methods in your derived class. See below for more information about [the intention of workload](#workload-philosophy)
 
-Below this class, implement a small loop that will generate all the test cases by reading the
-`canonical-data.json` file, and looping through the test cases.
-
-You will need to adjust the logic to match the structure of the canonical data.
-
-For example, if there is a single top-level key named "cases", then you can loop through
-them as follows:
-
-```
-ProblemNameCases = proc do |data|
-  JSON.parse(data)['cases'].map.with_index do |row, i|
-    ProblemNameCase.new(row.merge('index' => i))
-  end
-end
-```
-
-If there are multiple sections, then you will need to loop through the sections, and then
-loop through each of the cases in an inner loop:
-
-```
-ProblemNameCases = proc do |data|
-  json = JSON.parse(data)
-  cases = []
-  %w(section1 section2 etc).each do |section|
-    json[section]['cases'].each do |row|
-      row = row.merge(row.merge('index' => cases.size, 'section' => section))
-      cases << ProblemNameCase.new(row)
-    end
-  end
-  cases
-end
-```
-
 Finally, you need to create a text template, `example.tt`, as the bases for the test suite.
 
 Start with the following boilerplate, and adjust as necessary. Remember, however, to strive

data/tracks/ruby/exercises/acronym/.meta/.version

@@ -1 +1 @@
-2
+3

data/tracks/ruby/exercises/acronym/acronym_test.rb

@@ -3,36 +3,41 @@ gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
 require_relative 'acronym'
 
-# Test data version:
-# 5b5e807
+# Common test data version: dcfe476
 class AcronymTest < Minitest::Test
   def test_basic
-    assert_equal 'PNG', Acronym.abbreviate('Portable Network Graphics')
+    # skip
+    assert_equal "PNG", Acronym.abbreviate('Portable Network Graphics')
   end
 
   def test_lowercase_words
     skip
-    assert_equal 'ROR', Acronym.abbreviate('Ruby on Rails')
+    assert_equal "ROR", Acronym.abbreviate('Ruby on Rails')
   end
 
   def test_camelcase
     skip
-    assert_equal 'HTML', Acronym.abbreviate('HyperText Markup Language')
+    assert_equal "HTML", Acronym.abbreviate('HyperText Markup Language')
   end
 
   def test_punctuation
     skip
-    assert_equal 'FIFO', Acronym.abbreviate('First In, First Out')
+    assert_equal "FIFO", Acronym.abbreviate('First In, First Out')
   end
 
   def test_all_caps_words
     skip
-    assert_equal 'PHP', Acronym.abbreviate('PHP: Hypertext Preprocessor')
+    assert_equal "PHP", Acronym.abbreviate('PHP: Hypertext Preprocessor')
+  end
+
+  def test_non_acronym_all_caps_word
+    skip
+    assert_equal "GIMP", Acronym.abbreviate('GNU Image Manipulation Program')
   end
 
   def test_hyphenated
     skip
-    assert_equal 'CMOS', Acronym.abbreviate('Complementary metal-oxide semiconductor')
+    assert_equal "CMOS", Acronym.abbreviate('Complementary metal-oxide semiconductor')
   end
 
   # Problems in exercism evolve over time, as we find better ways to ask
@@ -54,6 +59,6 @@ class AcronymTest < Minitest::Test
 
   def test_bookkeeping
     skip
-    assert_equal 2, BookKeeping::VERSION
+    assert_equal 3, BookKeeping::VERSION
   end
 end

data/tracks/ruby/exercises/acronym/example.rb

@@ -1,5 +1,5 @@
 module BookKeeping
-  VERSION = 2
+  VERSION = 3
 end
 
 class Acronym

data/tracks/ruby/exercises/acronym/example.tt

@@ -4,13 +4,16 @@ require 'minitest/autorun'
 require_relative 'acronym'
 
 # Common test data version: <%= abbreviated_commit_hash %>
-class AcronymTest < Minitest::Test<% test_cases.each do |test_case| %>
-  def <%= test_case.name %><% if test_case.skipped? %>
-    skip<% end %>
-    assert_equal '<%= test_case.expected %>', <%= test_case.assertion %>
+class AcronymTest < Minitest::Test
+<% test_cases.each do |test_case| %>
+  def <%= test_case.name %>
+    <%= test_case.skipped %>
+    <%= test_case.workload %>
   end
+
 <% end %>
 <%= IO.read(XRUBY_LIB + '/bookkeeping.md') %>
+
   def test_bookkeeping
     skip
     assert_equal <%= version %>, BookKeeping::VERSION