trackler 2.2.1.44 → 2.2.1.45

data/tracks/rust/exercises/phone-number/tests/phone-number.rs

@@ -5,26 +5,26 @@ fn to_some_string(s: &str) -> Option<String> {
 }
 
 #[test]
-fn test_number_cleans() {
-    assert_eq!(phone::number("(123) 456-7890"), to_some_string("1234567890"));
+fn test_cleans_the_number() {
+    assert_eq!(
+        phone::number("(223) 456-7890"),
+        to_some_string("2234567890")
+    );
 }
 
 #[test]
 #[ignore]
-fn test_number_cleans_with_dots() {
-    assert_eq!(phone::number("123.456.7890"), to_some_string("1234567890"));
+fn test_cleans_numbers_with_dots() {
+    assert_eq!(phone::number("223.456.7890"), to_some_string("2234567890"));
 }
 
 #[test]
 #[ignore]
-fn test_valid_when_11_digits_and_first_is_1() {
-    assert_eq!(phone::number("11234567890"), to_some_string("1234567890"));
-}
-
-#[test]
-#[ignore]
-fn test_invalid_when_11_digits() {
-    assert_eq!(phone::number("21234567890"), None);
+fn test_cleans_numbers_with_multiple_spaces() {
+    assert_eq!(
+        phone::number("223 456   7890   "),
+        to_some_string("2234567890")
+    );
 }
 
 #[test]
@@ -35,60 +35,51 @@ fn test_invalid_when_9_digits() {
 
 #[test]
 #[ignore]
-fn test_invalid_when_empty() {
-    assert_eq!(phone::number(""), None);
-}
-
-#[test]
-#[ignore]
-fn test_invalid_when_no_digits_present() {
-    assert_eq!(phone::number(" (-) "), None);
-}
-
-#[test]
-#[ignore]
-fn test_valid_with_leading_characters() {
-    assert_eq!(phone::number("my number is 123 456 7890"), to_some_string("1234567890"));
+fn test_invalid_when_11_digits_does_not_start_with_a_1() {
+    assert_eq!(phone::number("22234567890"), None);
 }
 
 #[test]
 #[ignore]
-fn test_valid_with_trailing_characters() {
-    assert_eq!(phone::number("123 456 7890 - bob"), to_some_string("1234567890"));
+fn test_valid_when_11_digits_and_starting_with_1() {
+    assert_eq!(phone::number("12234567890"), to_some_string("2234567890"));
 }
 
 #[test]
 #[ignore]
-fn test_area_code() {
-    assert_eq!(phone::area_code("1234567890"), to_some_string("123"));
+fn test_valid_when_11_digits_and_starting_with_1_even_with_punctuation() {
+    assert_eq!(
+        phone::number("+1 (223) 456-7890"),
+        to_some_string("2234567890")
+    );
 }
 
 #[test]
 #[ignore]
-fn test_area_code_with_full_us_phone_number() {
-    assert_eq!(phone::area_code("18234567890"), to_some_string("823"));
+fn test_invalid_when_more_than_11_digits() {
+    assert_eq!(phone::number("321234567890"), None);
 }
 
 #[test]
 #[ignore]
-fn test_area_code_with_invalid() {
-    assert_eq!(phone::area_code("1234161567890"), None);
+fn test_invalid_with_letters() {
+    assert_eq!(phone::number("123-abc-7890"), None);
 }
 
 #[test]
 #[ignore]
-fn test_pretty_print() {
-    assert_eq!(phone::pretty_print("1234567890"), "(123) 456-7890");
+fn test_invalid_with_punctuations() {
+    assert_eq!(phone::number("123-@:!-7890"), None);
 }
 
 #[test]
 #[ignore]
-fn test_pretty_print_with_full_us_phone_number() {
-    assert_eq!(phone::pretty_print("11234567890"), "(123) 456-7890");
+fn test_invalid_if_area_code_does_not_start_with_2_9() {
+    assert_eq!(phone::number("(123) 456-7890"), None);
 }
 
 #[test]
 #[ignore]
-fn test_pretty_print_with_invalid() {
-    assert_eq!(phone::pretty_print("1186234567890"), "invalid");
+fn test_invalid_if_exchange_code_does_not_start_with_2_9() {
+    assert_eq!(phone::number("(223) 056-7890"), None);
 }

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

@@ -14,12 +14,14 @@ fn test_zero() {
 //
 /*
 #[test]
+#[ignore]
 fn test_negative() {
     assert_eq!(say::encode(-1), String::from("won't compile"));
 }
 */
 
 #[test]
+#[ignore]
 fn test_one() {
     assert_eq!(say::encode(1), String::from("one"));
 }

data/tracks/rust/exercises/sum-of-multiples/README.md

@@ -8,9 +8,6 @@ multiples of either 3 or 5, we get 3, 5, 6 and 9, 10, 12, 15, and 18.
 
 The sum of these multiples is 78.
 
-Given a number, find the sum of the multiples of a given set of numbers,
-up to but not including that number.
-
 ## Rust Installation
 
 Refer to the [exercism help page][help-page] for Rust installation and learning

data/tracks/scala/config.json

@@ -82,6 +82,17 @@
         "Transforming"
       ]
     },
+    {
+      "uuid": "65a76aba-a485-222d-84ba-e9a445b25be6",
+      "slug": "collatz-conjecture",
+      "core": true,
+      "unlocked_by": "leap",
+      "difficulty": 2,
+      "topics": [
+        "Recursion",
+        "Mathematics"
+      ]
+    },
     {
       "uuid": "5a31217f-02fd-4be4-b64f-7a93f36f5140",
       "slug": "hamming",

data/tracks/scala/exercises/collatz-conjecture/README.md

@@ -0,0 +1,43 @@
+## Collatz Conjecture.
+
+The Collatz Conjecture or 3x+1 problem can be summarized as follows:
+
+Take any positive integer n. If n is even, divide n by 2 to get n / 2. If n is
+odd, multiply n by 3 and add 1 to get 3n + 1. Repeat the process indefinitely.
+The conjecture states that no matter which number you start with, you will
+always reach 1 eventually.
+
+Given a number n, return the number of steps required to reach 1.
+
+## Examples
+Starting with n = 12, the steps would be as follows:
+
+0. 12
+1. 6
+2. 3
+3. 10
+4. 5
+5. 16
+6. 8
+7. 4
+8. 2
+9. 1
+
+Resulting in 9 steps. So for input n = 12, the return value would be 9.
+
+The Scala exercises assume an SBT project scheme. The exercise solution source
+should be placed within the exercise directory/src/main/scala. The exercise
+unit tests can be found within the exercise directory/src/test/scala.
+
+To run the tests simply run the command `sbt test` in the exercise directory.
+
+For more detailed info about the Scala track see the [help
+page](http://exercism.io/languages/scala).
+
+## Source
+
+An unsolved problem in mathematics named after mathematician Lothar Collatz
+see more at [collatz conjecture wikipedia](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/scala/exercises/collatz-conjecture/build.sbt

@@ -0,0 +1,3 @@
+scalaVersion := "2.11.7"
+
+libraryDependencies += "org.scalatest" % "scalatest_2.11" % "2.2.5" % "test"

data/tracks/scala/exercises/collatz-conjecture/example.scala

@@ -0,0 +1,17 @@
+object CollatzConjecture {
+
+  def isEven( v:Int ): Boolean = v % 2 == 0
+
+  def collatz_h(n: Int, acc: Int): Option[Int] = {
+    if (n <= 0)
+      None
+    else if (n == 1){
+      Some(acc)
+    } else if (isEven(n)){
+      collatz_h(n/2, acc+1)
+    } else{
+      collatz_h(n*3 + 1, acc+1)}
+  }
+
+  def steps(n: Int): Option[Int] = collatz_h(n, 0)
+}

data/tracks/scala/exercises/collatz-conjecture/src/test/scala/CollatzConjectureTest.scala

@@ -0,0 +1,34 @@
+import org.scalatest.{Matchers, FunSuite}
+
+/** @version 1.1.1 */
+class CollatzConjectureTest extends FunSuite with Matchers {
+  
+  test("zero steps for one") {
+    CollatzConjecture.steps(1) should be (Some(0))
+  }
+
+  test("divide if even") {
+    pending
+    CollatzConjecture.steps(16) should be (Some(4))
+  }
+
+  test("even and odd steps") {
+    pending
+    CollatzConjecture.steps(12) should be (Some(9))
+  }
+
+  test("Large number of even and odd steps") {
+    pending
+    CollatzConjecture.steps(1000000) should be (Some(152))
+  }
+
+  test("zero is an error") {
+    pending
+    CollatzConjecture.steps(0) should be (None)
+  }
+
+  test("negative value is an error") {
+    pending
+    CollatzConjecture.steps(-15) should be (None)
+  }
+}

data/tracks/scala/testgen/src/main/scala/CollatzConjectureTestGenerator.scala

@@ -0,0 +1,35 @@
+import java.io.File
+
+import testgen.TestSuiteBuilder._
+import testgen._
+
+object CollatzConjectureTestGenerator {
+  def main(args: Array[String]): Unit = {
+    val file = new File("src/main/resources/collatz-conjecture.json")
+
+    def toString(expected: CanonicalDataParser.Expected): String = {
+      expected match {
+        case Left(_) => "None"
+        case Right(null) => "None"
+        case Right(n) => s"Some($n)"
+      }
+    }
+
+    def fromLabeledTest(argNames: String*): ToTestCaseData =
+      withLabeledTest { sut =>
+        labeledTest =>
+          val args = sutArgs(labeledTest.result, argNames: _*)
+          val property = labeledTest.property
+          val sutCall =
+            s"""$sut.$property($args)"""
+          val expected = toString(labeledTest.expected)
+          TestCaseData(labeledTest.description, sutCall, expected)
+      }
+
+    val code = TestSuiteBuilder.build(file, fromLabeledTest("number"))
+
+    println(s"-------------")
+    println(code)
+    println(s"-------------")
+  }
+}

data/tracks/scheme/config.json

@@ -112,6 +112,14 @@
       "topics": null,
       "unlocked_by": null,
       "uuid": "5b44ccd4-b1f4-4b86-89c8-f1dec5905ccb"
+    },
+    {
+      "core": false,
+      "difficulty": 1,
+      "slug": "word-count",
+      "topics": null,
+      "unlocked_by": null,
+      "uuid": "9460b65d-dc80-4a95-8782-b395d2cc979e"
     }
   ],
   "foregone": [],

data/tracks/scheme/exercises/word-count/README.md

@@ -0,0 +1,19 @@
+# Word Count
+
+Given a phrase, count the occurrences of each word in that phrase.
+
+For example, given the input `"olly olly in come free"`
+
+```plain
+olly: 2
+in: 1
+come: 1
+free: 1
+```
+
+## Source
+
+This is a classic toy problem, but we were reminded of it by seeing it in the Go Tour.
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/scheme/exercises/word-count/example.scm

@@ -0,0 +1,27 @@
+(define-module (word-count)
+  #:use-module (srfi srfi-1)
+  #:use-module (ice-9 regex)
+  #:export (countwords))
+
+
+(define (countword word counters)
+  (let* ((oldcount (assoc-ref counters word))
+         (newcount (if oldcount (+ oldcount 1) 1)))
+    (assoc-set! counters word newcount)))
+
+
+(define (replace text pattern replacement)
+  (regexp-substitute/global #f pattern text 'pre replacement 'post))
+
+
+(define (normalize phrase)
+  (let* ((nopuncts (replace phrase "[.,\n!&@%:^$]" " "))
+         (onespace (replace nopuncts "[ ]+" " "))
+         (endspace (replace onespace "[ ]+$" ""))
+         (noquotes (replace endspace "( ')|(' )" " ")))
+    (string-downcase noquotes)))
+
+
+(define (countwords phrase)
+  (fold countword '()
+    (string-split (normalize phrase) #\space)))

data/tracks/scheme/exercises/word-count/word-count-test.scm

@@ -0,0 +1,90 @@
+;; Load SRFI-64 lightweight testing specification
+(use-modules (srfi srfi-64))
+
+;; Suppress log file output. To write logs, comment out the following line:
+(module-define! (resolve-module '(srfi srfi-64)) 'test-log-to-file #f)
+
+;; Require module
+(add-to-load-path (dirname (current-filename)))
+(use-modules (word-count))
+
+;; Tests for countwords
+(test-begin "countwords")
+
+
+(test-equal "count one word"
+  (assoc-ref (countwords "word") "word") 1)
+
+
+(test-assert "count one of each word"
+  (let ((result (countwords "one of each")))
+    (and (equal? (assoc-ref result "one") 1)
+         (equal? (assoc-ref result "of") 1)
+         (equal? (assoc-ref result "each") 1))))
+
+
+(test-assert "multiple occurrences of a word"
+  (let ((result (countwords "one fish two fish red fish blue fish")))
+    (and (equal? (assoc-ref result "one") 1)
+         (equal? (assoc-ref result "fish") 4)
+         (equal? (assoc-ref result "two") 1)
+         (equal? (assoc-ref result "red") 1)
+         (equal? (assoc-ref result "blue") 1))))
+
+
+(test-assert "handles cramped lists"
+  (let ((result (countwords "one,two,three")))
+    (and (equal? (assoc-ref result "one") 1)
+         (equal? (assoc-ref result "two") 1)
+         (equal? (assoc-ref result "three") 1))))
+
+
+(test-assert "handles expanded lists"
+  (let ((result (countwords "one,\ntwo,\nthree")))
+    (and (equal? (assoc-ref result "one") 1)
+         (equal? (assoc-ref result "two") 1)
+         (equal? (assoc-ref result "three") 1))))
+
+
+(test-assert "ignore punctuation"
+  (let ((result (countwords "car: carpet as java: javascript!!&@$%^&")))
+    (and (equal? (assoc-ref result "car") 1)
+         (equal? (assoc-ref result "carpet") 1)
+         (equal? (assoc-ref result "as") 1)
+         (equal? (assoc-ref result "java") 1)
+         (equal? (assoc-ref result "javascript") 1))))
+
+
+(test-assert "include numbers"
+  (let ((result (countwords "testing, 1, 2 testing")))
+    (and (equal? (assoc-ref result "testing") 2)
+         (equal? (assoc-ref result "1") 1)
+         (equal? (assoc-ref result "2") 1))))
+
+
+(test-assert "normalize case"
+  (let ((result (countwords "go Go GO Stop stop")))
+    (and (equal? (assoc-ref result "go") 3)
+         (equal? (assoc-ref result "stop") 2))))
+
+
+(test-assert "with apostrophes"
+  (let ((result (countwords "First: don't laugh. Then: don't cry.")))
+    (and (equal? (assoc-ref result "first") 1)
+         (equal? (assoc-ref result "don't") 2)
+         (equal? (assoc-ref result "laugh") 1)
+         (equal? (assoc-ref result "then") 1)
+         (equal? (assoc-ref result "cry") 1))))
+
+
+(test-assert "with quotations"
+  (let ((result (countwords "Joe can't tell between 'large' and large.")))
+    (and (equal? (assoc-ref result "joe") 1)
+         (equal? (assoc-ref result "can't") 1)
+         (equal? (assoc-ref result "tell") 1)
+         (equal? (assoc-ref result "between") 1)
+         (equal? (assoc-ref result "large") 2)
+         (equal? (assoc-ref result "and") 1))))
+
+
+(test-end "countwords")

data/tracks/scheme/exercises/word-count/word-count.scm

@@ -0,0 +1,5 @@
+(define-module (word-count)
+  #:export (countwords))
+
+(define (countwords phrase)
+  '())

data/tracks/sml/README.md

@@ -91,11 +91,30 @@ bin/generate {{ slug }}
 
 It will create the exercise directory, test and stub files.
 
+### Generator
+
+```
+usage: generate [-h] [--force] [--test-only] [--stub-only] [--example-only]
+                exercises [exercises ...]
+
+positional arguments:
+  exercises
+
+optional arguments:
+  -h, --help      show this help message and exit
+  --force         Type inference will be disabled and "string" will be
+                  assumed. Test cases will need to be modified to match the
+                  right data type.
+  --test-only     Generate only "test.sml"
+  --stub-only     Generate only "<exercise>.sml"
+  --example-only  Generate only "example.sml"
+```
+
 **Note:**
 - You need Python 3.5+.
 - It may fail with some exercises. Reasons:
   - `canonical-data.json` does not exist
-  - type mismatch
+  - type mismatch (in these situation you can use `--force` option)
 
 In those cases you will have to create the files manually. `testlib.sml` can be copied from `lib/testlib.sml`. When in doubt, feel free to open an issue.
 

data/tracks/sml/bin/generate

@@ -42,7 +42,9 @@ def camelize(s):
     return re.sub('[-_](\w)', lambda x: x.group(1).upper(), s)
 
 
-def sml_type(value):
+def sml_type(value, force=False):
+    if force:
+        return 'string'
     if value is None:
         return 'option'
     if isinstance(value, list):
@@ -72,7 +74,9 @@ def sml_type(value):
     return types[type(value)]
 
 
-def sml_value(value, smltype=''):
+def sml_value(value, smltype='', force=False):
+    if force:
+        return json.dumps(value)
     if value is None:
         return 'NONE'
     _value = None
@@ -104,12 +108,12 @@ def get_fn_args(case):
     )
 
 
-def extract_signatures(data):
+def extract_signatures(data, force=False):
     funcs = OrderedDict()
     exercise = data['exercise']
 
     def type_aux(values):
-        s = {sml_type(val) for val in values}
+        s = {sml_type(val, force=force) for val in values}
         if len(s) == 1:
             return s.pop()
         if len(s) == 2 and 'option' in s:
@@ -136,10 +140,10 @@ def extract_signatures(data):
             else:
                 # assumes there's at least one test with non "nullish" vars
                 fn = camelize(case.get('property', exercise))
-                if sml_type(case['expected']) == 'exn':
+                if sml_type(case['expected'], force=force) == 'exn':
                     continue
                 args = get_fn_args(case)
-                if not all(args.values()) or sml_type(case['expected']) == "'a list":# or not case['expected']:
+                if not all(args.values()) or sml_type(case['expected'], force=force) == "'a list":# or not case['expected']:
                     continue
                 funcs.setdefault(fn, []).append({
                     'args': args,
@@ -150,17 +154,17 @@ def extract_signatures(data):
     return {fn: signature(funcs[fn]) for fn in funcs}
 
 
-def expectation(signature, fn, args, expected):
+def expectation(signature, fn, args, expected, force=False):
     tmpl = '(fn _ => %s |> Expect.%s)'
-    output = sml_value(expected, signature['output'])
+    output = sml_value(expected, signature['output'], force=force)
     invocation = '%s (%s)' % (
         fn,
         ', '.join((
-            sml_value(val, signature['args'][arg])
+            sml_value(val, signature['args'][arg], force=force)
             for arg, val in args.items())
         )
     )
-    if sml_type(expected) == 'exn':
+    if sml_type(expected, force=force) == 'exn':
         return tmpl % (
             '(fn _ => %s)' % invocation,
             'error (%s)' % output
@@ -181,7 +185,7 @@ def expectation(signature, fn, args, expected):
     )
 
 
-def generate_test_content(data, signature):
+def generate_test_content(data, signature, force=False):
     exercise = data['exercise']
 
     def fmt(case, depth=0):
@@ -192,7 +196,7 @@ def generate_test_content(data, signature):
         args = get_fn_args(case)
         return '\n'.join((
             indent(depth, 'test "%s"' % case.get('description', fn)),
-            indent(depth + 2, expectation(signature[fn], fn, args, expected))
+            indent(depth + 2, expectation(signature[fn], fn, args, expected, force=force))
         ))
 
     def traverse(cases, depth=0):
@@ -247,17 +251,33 @@ def write(path, content):
         f.write(content)
 
 
-def generate(exercise):
+# flags
+TEST = 1
+STUB = 2
+EXAMPLE = 4
+FLAGS = TEST | STUB | EXAMPLE
+
+
+def generate(exercise, flags, force=False):
     root = Path(__file__).parent.parent.absolute()
     path = root / 'exercises' / exercise
+
     if not path.exists():
         path.mkdir()
+
     data = fetch(exercise)
-    signatures = extract_signatures(data)
-    write(path / 'test.sml', generate_test_content(data, signatures))
+    signatures = extract_signatures(data, force=force)
     content = generate_exercise_content(signatures)
-    write(path / ('%s.sml' % exercise), content)
-    write(path / 'example.sml', content)
+
+    if flags & TEST:
+        write(path / 'test.sml', generate_test_content(data, signatures, force=force))
+
+    if flags & STUB:
+        write(path / ('%s.sml' % exercise), content)
+
+    if flags & EXAMPLE:
+        write(path / 'example.sml', content)
+
     shutil.copyfile(
         (root / 'lib/testlib.sml').as_posix(),
         (path / 'testlib.sml').as_posix()
@@ -265,11 +285,45 @@ def generate(exercise):
 
 
 if __name__ == '__main__':
-    import sys
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('exercises', nargs='+')
+    parser.add_argument(
+        '--force',
+        action='store_true',
+        help=(
+            'Type inference will be disabled and "string" will be assumed. ' +
+            'Test cases will need to be modified to match the right data type.'
+        )
+    )
+    parser.add_argument(
+        '--test-only',
+        action='store_true',
+        help='Generate only "test.sml"'
+    )
+    parser.add_argument(
+        '--stub-only',
+        action='store_true',
+        help='Generate only "<exercise>.sml"'
+    )
+    parser.add_argument(
+        '--example-only',
+        action='store_true',
+        help='Generate only "example.sml"'
+    )
+    args = parser.parse_args()
 
-    for exercise in sys.argv[1:]:
+    for exercise in args.exercises:
         try:
-            generate(exercise)
+            flags = 0
+            if args.test_only:
+                flags |= ~(STUB | EXAMPLE)
+            if args.example_only:
+                flags |= ~(STUB | TEST)
+            if args.stub_only:
+                flags |= ~(TEST | EXAMPLE)
+            generate(exercise, force=args.force, flags=flags or FLAGS)
         except FileNotFoundError:
             print('[%s]: canonical-data.json not found' % exercise)
         except Exception as e: