trackler 2.2.1.95 → 2.2.1.96

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe25bae56189cb9dd2f98c3dd8a9e08f1de442c7
-  data.tar.gz: cf7251e1202e956a8c2d8bde50aea6b834f78785
+  metadata.gz: 81eca53e081d3529ffccdc505c2470677bcd75fa
+  data.tar.gz: 5c658d2fdc47d731a5c12857851e327019bfcf0f
 SHA512:
-  metadata.gz: c5bc03f80fd2457525a2bc01b1e225926c1d521c601114892130859c891eb2f3847f2082fe1e741793b1c2af534d3c3b70aea8419e33301fbaa6aa5db503d514
-  data.tar.gz: 600e433bf221bd210e9bdada5c051c8725fc41e6326b4e14904f72ad043249934c93f485408e1502a01367efb8e2925c9d1df75cecb291d9622a8303d81660b8
+  metadata.gz: dcb54de6244b11bc2ac9ade0eee35db7a0436a8fbb1eabcd8f5d6be9e46df5a4d35015df8f3f0c31ffb470b766bce0d0b07fb426566a22de1ca454809860f3a1
+  data.tar.gz: b188c9715563d6aa42540f7f85295b58c99841515fdcc8ef9e3322d8887006a8a08ac664bc05bf7a0875d94019e9e8901f46d0a6e4a937283162775204e9fe57

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.95"
+  VERSION = "2.2.1.96"
 end

data/problem-specifications/exercises/two-bucket/canonical-data.json

@@ -1,95 +1,95 @@
 {
   "exercise": "two-bucket",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "cases": [
     {
       "description": "Measure using bucket one of size 3 and bucket two of size 5 - start with bucket one",
       "property": "measure",
       "input": {
-        "bucket_one": 3,
-        "bucket_two": 5,
+        "bucketOne": 3,
+        "bucketTwo": 5,
         "goal": 1,
-        "start_bucket": "one"
+        "startBucket": "one"
       },
       "expected": {
         "moves": 4,
-        "goal_bucket": "one",
-        "other_bucket": 5
+        "goalBucket": "one",
+        "otherBucket": 5
       }
     },
     {
       "description": "Measure using bucket one of size 3 and bucket two of size 5 - start with bucket two",
       "property": "measure",
       "input": {
-        "bucket_one": 3,
-        "bucket_two": 5,
+        "bucketOne": 3,
+        "bucketTwo": 5,
         "goal": 1,
-        "start_bucket": "two"
+        "startBucket": "two"
       },
       "expected": {
         "moves": 8,
-        "goal_bucket": "two",
-        "other_bucket": 3
+        "goalBucket": "two",
+        "otherBucket": 3
       }
     },
     {
       "description": "Measure using bucket one of size 7 and bucket two of size 11 - start with bucket one",
       "property": "measure",
       "input": {
-        "bucket_one": 7,
-        "bucket_two": 11,
+        "bucketOne": 7,
+        "bucketTwo": 11,
         "goal": 2,
-        "start_bucket": "one"
+        "startBucket": "one"
       },
       "expected": {
         "moves": 14,
-        "goal_bucket": "one",
-        "other_bucket": 11
+        "goalBucket": "one",
+        "otherBucket": 11
       }
     },
     {
       "description": "Measure using bucket one of size 7 and bucket two of size 11 - start with bucket two",
       "property": "measure",
       "input": {
-        "bucket_one": 7,
-        "bucket_two": 11,
+        "bucketOne": 7,
+        "bucketTwo": 11,
         "goal": 2,
-        "start_bucket": "two"
+        "startBucket": "two"
       },
       "expected": {
         "moves": 18,
-        "goal_bucket": "two",
-        "other_bucket": 7
+        "goalBucket": "two",
+        "otherBucket": 7
       }
     },
     {
       "description": "Measure one step using bucket one of size 1 and bucket two of size 3 - start with bucket two",
       "property": "measure",
       "input": {
-        "bucket_one": 1,
-        "bucket_two": 3,
+        "bucketOne": 1,
+        "bucketTwo": 3,
         "goal": 3,
-        "start_bucket": "two"
+        "startBucket": "two"
       },
       "expected": {
         "moves": 1,
-        "goal_bucket": "two",
-        "other_bucket": 0
+        "goalBucket": "two",
+        "otherBucket": 0
       }
     },
     {
       "description": "Measure using bucket one of size 2 and bucket two of size 3 - start with bucket one and end with bucket two",
       "property": "measure",
       "input": {
-        "bucket_one": 2,
-        "bucket_two": 3,
+        "bucketOne": 2,
+        "bucketTwo": 3,
         "goal": 3,
-        "start_bucket": "one"
+        "startBucket": "one"
       },
       "expected": {
         "moves": 2,
-        "goal_bucket": "two",
-        "other_bucket": 2
+        "goalBucket": "two",
+        "otherBucket": 2
       }
     }
   ]

data/tracks/csharp/docs/ABOUT.md

@@ -1,5 +1,23 @@
-C# is a modern, object oriented language developed and maintained by Microsoft. The learning curve is small, reduced even if the developer has experience with other 'C-Style' languages.
+C# is a multi-paradigm, statically-typed programming language with object-oriented, declarative, functional, generic, lazy, integrated querying features and type inference. 
 
-C# is a carefully designed language with lots of great features, such as type-inference and async/await. The official [documentation](https://docs.microsoft.com/en-us/dotnet/csharp/) is very extensive and well-written.
+__Statically-typed__ means that identifiers have a [type](https://en.wikipedia.org/wiki/Type_system#Static_type_checking) set at compile time--like those in Java, C++ or Haskell--instead of holding data of any type like those in Python, Ruby or JavaScript. 
 
-Although .NET used to be Windows-only, with the release of [.NET Core](https://www.microsoft.com/net/core) you can also use C# on Mac or Unix-based systems.
+__Object-oriented__ means that C# provides imperative [class-based objects](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/object-oriented-programming) with features such as single inheritance, interfaces and encapsulation.  
+
+__Declarative__ means programming [what is to be done](https://stackoverflow.com/questions/1784664/what-is-the-difference-between-declarative-and-imperative-programming), as opposed to how it is done (a.k.a imperative programming) (which is an implementation detail which can distract from the domain or business logic).
+
+__Functional__ means that [functions are first-class data types](https://livebook.manning.com/#!/book/functional-programming-in-c-sharp/chapter-1) that can be passed as arguments to and returned from other functions. 
+
+__Generic__ means that algorithms are written in terms of types [to-be-specified-later](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/generic-type-parameters) that are then instantiated, when needed, for the specific types provided as parameters. 
+
+__Lazy__ [(a.k.a "deferred execution")](https://blogs.msdn.microsoft.com/pedram/2007/06/02/lazy-evaluation-in-c/) means that the compiler will put off evaluating an item until required. This lets one safely do weird stuff like operating on an infinite list--the language will only create the list up to the last value needed.
+
+__Integrated Querying__ means the language feature called [LINQ "Language-Integrated Query"](https://msdn.microsoft.com/en-us/library/bb308959.aspx), which enables lazy querying directly within the language, not only its own objects but, also, external data sources through formats such as XML, JSON, SQL, NoSQL DBs and event streams.  
+
+__Type inference__ means that the compiler will often figure out the type of an identifier by itself so you don't have to specify it. Scala and F# both do this.
+
+__Syntax__ is similar to that of other C-style languages such as C, C++ and Java.
+
+__.NET__ is the managed environment within which C# runs, so you get access to the entire .NET ecosystem, including all packages on [nuget.org](http://www.nuget.org). .NET used to be Windows-only but, with the release of [.NET Core](https://www.microsoft.com/net/core) -- as well as [Mono](http://www.mono-project.com/) -- you can also use C# on Mac, Linux or Unix-based systems and on mobile platforms too. 
+
+C# also has features, amongst others, to make programming with multiple threads/processors, parallelisation, asynchrony, unmanaged code in a managed environment and language interoperability easier. It is developed and maintained by Microsoft, who provides the official [documentation](https://docs.microsoft.com/en-us/dotnet/csharp/).

data/tracks/dart/.travis.yml

@@ -3,7 +3,6 @@ language: dart
 sudo: false
 
 dart:
-  - dev
   - stable
 
 dart_task:
@@ -19,4 +18,4 @@ before_script:
 script:
   - bin/fetch-configlet
   - bin/configlet lint .
-  - pub run test
+  - pub run test test/

data/tracks/dart/README.md

@@ -12,7 +12,7 @@ Clone the repo and run `pub get` to download all the dependencies for this proje
 
 To run all the tests execute: `pub run test`
 
-To create a new exercise, use the create-exercise executable in the tool directory: `./tool/create_exercise`
+To create a new exercise, use the executable in the tool directory: `dart bin/create_exercise.dart`
 
 ## Exercise Tests ##
 
@@ -42,4 +42,4 @@ We welcome pull requests of all kinds. No contribution is too small.
 
 We encourage contributions that provide fixes and improvements to existing exercises. Please note that this track's exercises must conform to the standards determined in the [exercism/problem-specifications](https://github.com/exercism/problem-specifications) repo. Changes to the tests or documentation of a common exercise will often warrant a PR in that repo before it can be incorporated into this track's exercises. If you're unsure, then go ahead and open a GitHub issue, and we'll discuss the change.
 
-Please read our [Contribution guidelines](CONTRIBUTING.md) on how to help this track!
+Please read our [Contribution guidelines](CONTRIBUTING.md) on how to help this track!

data/tracks/dart/{tool/create-exercise → bin/create_exercise.dart}

@@ -1,6 +1,3 @@
-#!/usr/bin/env dart
-// vim: set syntax=dart:
-
 import "dart:io";
 import "dart:async";
 import "dart:convert";
@@ -11,11 +8,13 @@ import "package:path/path.dart" show dirname;
 const ME = "create-exercise";
 
 final parser = new ArgParser()
-  ..addSeparator("Usage: $ME <slug> [--spec-path path]")
+  ..addSeparator("Usage: $ME [--spec-path path] <slug>")
   ..addOption("spec-path", help: "The location of the problem-specifications directory.", valueHelp: 'path');
 
 /** Helpers */
 List<String> words(String str) {
+  if (str == null) return [''];
+
   return str
       .toLowerCase()
       .replaceAll(new RegExp(r"[^a-z0-9]"), " ")
@@ -25,6 +24,8 @@ List<String> words(String str) {
 }
 
 String upperFirst(String str) {
+  if (str == null || str.length == 0) return '';
+
   final chars = str.split("");
   final first = chars.first;
 
@@ -127,7 +128,7 @@ String testCaseTemplate(String name, Map<String, Object> testCase, {bool firstTe
 /// Based on the python `repr` function, but only works for basic types: String, Iterable, Map, and primitive types
 String repr(Object x) {
   if (x is String) {
-    x = x.replaceAll('"', r'\"').replaceAll("\n", r"\n").replaceAll(r"$", r"\$");
+    x = (x as String).replaceAll('"', r'\"').replaceAll("\n", r"\n").replaceAll(r"$", r"\$");
     return '"$x"';
   }
 
@@ -148,7 +149,7 @@ String repr(Object x) {
 }
 
 /// A helper method to get the inside type of an iterable
-String getIterableType(Object iter) {
+String getIterableType(Iterable iter) {
   Set<String> types = iter.map(getFriendlyType).toSet();
 
   if (types.length == 1) {
@@ -176,7 +177,7 @@ String getFriendlyType(Object x) {
     return "num";
   }
 
-  return x.runtimeType;
+  return x.runtimeType.toString();
 }
 
 // runProcess runs a process, writes any stdout/stderr output.
@@ -217,6 +218,7 @@ Future main(args) async {
       File file = new File(filename);
       final specification = JSON.decode(await file.readAsString());
       testCasesString = testCaseTemplate(name, specification);
+      print("Found: ${arguments['spec-path']}/exercises/$name/canonical-data.json");
     } on FileSystemException {
       stderr.write("Could not open file '$filename', exiting.\n");
       exit(1);
@@ -224,6 +226,8 @@ Future main(args) async {
       stderr.write("File '$filename' is not valid JSON, exiting.\n");
       exit(1);
     }
+  } else {
+    print("Could not find: ${arguments['spec-path']}/exercises/$name/canonical-data.json");
   }
 
   if (await exerciseDir.exists()) {
@@ -257,10 +261,10 @@ Future main(args) async {
   // The output from file generation is not always well-formatted, use dartfmt to clean it up
   final fmtSuccess = await runProcess("dartfmt", ["-l", "120", "-w", exerciseDir.path]);
   if (fmtSuccess) {
-	  stdout.write("Successfully created a rough-draft of tests at '$testFileName'.\n");
-	  stdout.write("You should check this over and fix or refine as necessary.\n");
+    stdout.write("Successfully created a rough-draft of tests at '$testFileName'.\n");
+    stdout.write("You should check this over and fix or refine as necessary.\n");
   } else {
-	  stderr.write("Warning: dartfmt exited with an error, files in '${exerciseDir.path}' may be malformed.\n");
+    stderr.write("Warning: dartfmt exited with an error, files in '${exerciseDir.path}' may be malformed.\n");
   }
 
   // Install deps

data/tracks/dart/test/create_exercise_test.dart

@@ -0,0 +1,132 @@
+import 'package:test/test.dart';
+import '../bin/create_exercise.dart';
+
+void main() {
+  group('create-exercise tool', () {
+    group('helpers', () {
+      group('words', () {
+        test('null returns empty list', () {
+          expect(words(null), equals(['']));
+        });
+
+        test('empty string returns empty list', () {
+          expect(words(''), equals(['']));
+        });
+
+        test('single word returns list with single element', () {
+          expect(words('foobar'), equals(['foobar']));
+        });
+
+        test('upper case characters are converted to lower case', () {
+          expect(words('FOOBAR'), equals(['foobar']));
+        });
+
+        test('words separated by a space become individual list elements', () {
+          expect(words('foo bar'), equals(['foo', 'bar']));
+        });
+
+        test('all symbols are replaced by a space', () {
+          expect(words('foo@bar'), equals(['foo', 'bar']));
+        });
+
+        test('words can only contain letters and digits', () {
+          expect(words('foo bar...123'), equals(['foo', 'bar', '123']));
+        });
+
+        test('multiple occurrences of spaces are trimmed', () {
+          expect(words('   foo  bar '), equals(['foo', 'bar']));
+        });
+
+        test('all symbols are discarded', () {
+          expect(words('<foobar>'), equals(['foobar']));
+        });
+      });
+
+      group('upperFirst()', () {
+        test('null returns empty string', () {
+          expect(upperFirst(null), equals(''));
+        });
+
+        test('empty string returns empty string', () {
+          expect(upperFirst(''), equals(''));
+        });
+
+        test('a single lower case character is converted to upper case', () {
+          expect(upperFirst('a'), equals('A'));
+        });
+
+        test('a single upper case character remains upper case', () {
+          expect(upperFirst('A'), equals('A'));
+        });
+
+        test('a digit remains the same', () {
+          expect(upperFirst('0'), equals('0'));
+        });
+
+        test('a symbol remains the same', () {
+          expect(upperFirst('?'), equals('?'));
+        });
+
+        test('a lower case string returns the same string capitalized', () {
+          expect(upperFirst('foobar'), equals('Foobar'));
+        });
+
+        test('a capitalized string remains the same', () {
+          expect(upperFirst('Foobar'), equals('Foobar'));
+        });
+
+        test('only the first word in a string is capitalized', () {
+          expect(upperFirst('foo bar'), equals('Foo bar'));
+        });
+      });
+
+      group('camelCase()', () {
+        test('a lower case string remains the same', () {
+          expect(camelCase('foobar'), equals('foobar'));
+        });
+
+        test('returns capitalized string if isUpperFirst is true', () {
+          expect(camelCase('foobar', isUpperFirst: true), equals('Foobar'));
+        });
+
+        test('every word after the first is capitalized', () {
+          expect(camelCase('foo bar'), equals('fooBar'));
+        });
+
+        test('every word is capitalized if isUpperFirst is true', () {
+          expect(camelCase('foo bar', isUpperFirst: true), equals('FooBar'));
+        });
+      });
+
+      group('pascalCase()', () {
+        test('the first character is converted to upper case', () {
+          expect(pascalCase('foobar'), equals('Foobar'));
+        });
+
+        test('every word is capitalized', () {
+          expect(pascalCase('foo bar'), equals('FooBar'));
+        });
+      });
+
+      group('snakeCase()', () {
+        test('every word is separated by an underscore', () {
+          expect(snakeCase('foo bar'), equals('foo_bar'));
+        });
+
+        test('symbols are replaced by an underscore', () {
+          expect(snakeCase('foo-bar'), equals('foo_bar'));
+        });
+      });
+
+      group('kebabCase()', () {
+        test('every word is separated by a dash', () {
+          expect(kebabCase('foo bar'), equals('foo-bar'));
+        });
+
+        test('symbols are replaced by a dash', () {
+          expect(kebabCase('foo_bar'), equals('foo-bar'));
+        });
+      });
+    });
+  });
+}

data/tracks/dart/test/exercises_test.dart

@@ -1,4 +1,4 @@
-@Timeout(const Duration(seconds: 45))
+@Timeout(const Duration(seconds: 60))
 
 import "dart:io";
 import "dart:async";

data/tracks/fsharp/exercises/list-ops/Example.fs

@@ -5,7 +5,7 @@ let rec foldl folder state list =
     | [] -> state
     | x::xs -> foldl folder (folder state x) xs
 
-let rec foldr folder list state =
+let rec foldr folder state list =
     list
     |> List.rev
     |> foldl (fun acc item -> folder item acc) state
@@ -14,10 +14,10 @@ let length list = foldl (fun acc _ -> acc + 1) 0 list
 
 let reverse list = foldl (fun acc item -> item :: acc) [] list
 
-let map f list = foldr (fun item acc -> f item :: acc) list []
+let map f list = foldr (fun item acc -> f item :: acc) [] list
 
-let filter f list = foldr (fun item acc -> if f item then item :: acc else acc) list []
+let filter f list = foldr (fun item acc -> if f item then item :: acc else acc) [] list
 
-let append xs ys = foldr (fun item acc -> item :: acc) xs ys
+let append xs ys = foldr (fun item acc -> item :: acc) ys xs
 
-let concat xs = foldr append xs []
+let concat xs = foldr append [] xs