trackler 2.0.6.10 → 2.0.6.11

data/tracks/pony/exercises/anagram/test.pony

@@ -4,32 +4,25 @@ actor Main is TestList
   new create(env: Env) =>
     PonyTest(env, this)
 
-  new make() =>
-    None
-
   fun tag tests(test: PonyTest) =>
     test(_AnagramTest)
 
 class iso _AnagramTest is UnitTest
-  """
-  Test Anagram package
-  """
-
   fun name(): String => "anagram/Anagram"
 
-  fun apply(h: TestHelper): None ? =>
+  fun apply(h: TestHelper) =>
     let anagrams =  ["banana", "bob", "sent", "sale", "ales"]
-    let emptyArray: Array[String] = Array[String]
+    let empty = Array[String]
 
     // Anagram should return an empty array if there are no anagrams
-    h.assert_array_eq[String](emptyArray, Anagram("bobs", anagrams))
+    h.assert_array_eq[String](empty, Anagram("bobs", anagrams))
     // Anagram should ignore same words, those aren't anagrams
-    h.assert_array_eq[String](emptyArray, Anagram("banana", anagrams))
+    h.assert_array_eq[String](empty, Anagram("banana", anagrams))
     // Anagram shouldn't be based on checksum
-    h.assert_array_eq[String](emptyArray, Anagram("last", ["mass"]))
+    h.assert_array_eq[String](empty, Anagram("last", ["mass"]))
     // Anagram should return an array of anagrams if present
     h.assert_array_eq[String](["sent"], Anagram("nets", anagrams))
     // Anagram should be case insensitive
-    h.assert_array_eq[String](["sent"],Anagram("nETs", anagrams))
+    h.assert_array_eq[String](["sent"], Anagram("nETs", anagrams))
     // Anagram should return multiple anagrams
     h.assert_array_eq[String](["sale", "ales"], Anagram("seal", anagrams))

data/tracks/pony/exercises/bob/example.pony

@@ -1,33 +1,33 @@
-use "regex"
+use "itertools"
 
-// Not the best example. Will refactor when I grok the type system better.
-
-
-class Bob
-  let _default: String
-
-  new create() =>
-    _default = "Whatever."
-
-  fun apply(phrase: String): String ? =>
-    if loud(phrase) then
+primitive Bob
+  fun apply(phrase: String): String =>
+    if _silent(phrase) then
+      "Fine. Be that way!"
+    elseif _loud(phrase) then
       "Whoa, chill out!"
-    elseif question(phrase) then
+    elseif _question(phrase) then
       "Sure."
-    elseif silent(phrase) then
-      "Fine. Be that way!"
     else
-      _default
+      "Whatever."
     end
 
-  fun loud(phrase: String): Bool ? =>
-    (Regex("[A-Z]").eq(phrase)) and (phrase == phrase.upper())
+  fun _silent(phrase: String): Bool =>
+    phrase.clone().>strip() == ""
+
+  fun _loud(phrase: String): Bool =>
+    Iter[U8](phrase.values()).all(this~_not_lowercase())
+      and Iter[U8](phrase.values()).any(this~_is_letter())
 
-  fun question(phrase: String): Bool =>
-    let rephrase: String box = consume phrase
-    rephrase.reverse().at("?",0)
+  fun _not_lowercase(b: U8): Bool =>
+    (b < 'a') and ('z' > b)
 
+  fun _is_letter(b: U8): Bool =>
+    (('a' <= b) and (b <= 'z')) or (('A' <= b) and (b <= 'Z')) 
 
-  fun silent(phrase: String): Bool ? =>
-    let rephrase: String box = consume phrase
-    (rephrase.size() == 0) or Regex("^\\s+$").eq(rephrase)
+  fun _question(phrase: String): Bool =>
+    try
+      Iter[U8](phrase.values()).last() == '?'
+    else
+      false
+    end

data/tracks/pony/exercises/bob/test.pony

@@ -4,22 +4,16 @@ actor Main is TestList
   new create(env: Env) =>
     PonyTest(env, this)
 
-  new make() =>
-    None
-
   fun tag tests(test: PonyTest) =>
-    test(_BobShoutTest)
-    test(_BobQuestionTest)
-    test(_BobSilentTest)
-    test(_BobDefaultTest)
+    test(_TestBobShout)
+    test(_TestBobQuestion)
+    test(_TestBobSilent)
+    test(_TestBobDefault)
 
-class iso _BobShoutTest is UnitTest
-  """
-  Test matching when Bob is shouted at
-  """
-  fun name(): String => "bob/Bob"
+class iso _TestBobShout is UnitTest
+  fun name(): String => "bob/Bob (Whoa, chill out!)"
 
-  fun apply(h: TestHelper): None ? =>
+  fun apply(h: TestHelper) =>
     let shout_resp: String = "Whoa, chill out!"
 
     h.assert_eq[String](shout_resp, Bob("WATCH OUT!"))
@@ -27,14 +21,10 @@ class iso _BobShoutTest is UnitTest
     h.assert_eq[String](shout_resp, Bob("1, 2, 3 GO!"))
     h.assert_eq[String](shout_resp, Bob("ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!"))
 
-class iso _BobQuestionTest is UnitTest
-  """
-  Test matching when Bob is questioned
-  """
-
-  fun name(): String => "bob/Bob"
+class iso _TestBobQuestion is UnitTest
+  fun name(): String => "bob/Bob (Sure.)"
 
-  fun apply(h: TestHelper): None ? =>
+  fun apply(h: TestHelper) =>
     let ques_resp: String = "Sure."
 
     h.assert_eq[String](ques_resp, Bob("Does this cryogenic chamber make me look fat?"))
@@ -42,27 +32,19 @@ class iso _BobQuestionTest is UnitTest
     h.assert_eq[String](ques_resp, Bob("4?"))
     h.assert_eq[String](ques_resp, Bob("Wait! Hang on. Are you going to be OK?"))
 
-class iso _BobSilentTest is UnitTest
-  """
-  Test matching when Bob faces silence
-  """
+class iso _TestBobSilent is UnitTest
+  fun name(): String => "bob/Bob (Fine. Be that way!)"
 
-  fun name(): String => "bob/Bob"
-
-  fun apply(h: TestHelper): None ? =>
+  fun apply(h: TestHelper) =>
     let silent_resp: String = "Fine. Be that way!"
 
     h.assert_eq[String](silent_resp, Bob(""))
     h.assert_eq[String](silent_resp, Bob("   "))
 
-class iso _BobDefaultTest is UnitTest
-  """
-  Test matching when Bob is defaulting
-  """
-
-  fun name(): String => "bob/Bob"
+class iso _TestBobDefault is UnitTest
+  fun name(): String => "bob/Bob (Whatever.)"
 
-  fun apply(h: TestHelper): None ? =>
+  fun apply(h: TestHelper) =>
     let default_resp: String = "Whatever."
 
     h.assert_eq[String](default_resp, Bob("Tom-ay-to, tom-aaaah-to."))

data/tracks/pony/exercises/difference-of-squares/example.pony

@@ -1,31 +1,19 @@
 use "collections"
+use "itertools"
 
-class Squares
-  let _max: U32
-
-  new create(max: U32) =>
-    _max = max + 1
-
-  fun square_of_sums(): U32 =>
-    var sum: U32 = 0
-    let rng: Range[U32] = Range[U32](1, _max)
-
-    while rng.has_next() do
-      sum = sum + rng.next()
-    end
-
+primitive Squares
+  fun square_of_sums(n: USize): USize =>
+    let sum = (n * (n + 1)) / 2
     sum * sum
 
-  fun sum_of_squares(): U32 =>
-    var sum: U32 = 0
-    let rng: Range[U32] = Range[U32](1, _max)
-
-    while rng.has_next() do
-      var t: U32 = rng.next()
-      sum = sum + (t * t)
+  fun sum_of_squares(n: USize): USize =>
+    try
+      Iter[USize](Range(0, n + 1))
+        .map[USize]({(x: USize): USize => x * x})
+        .fold[USize]({(acc: USize, x: USize): USize => acc + x}, 0)
+    else
+      0
     end
 
-    sum
-
-  fun difference(): U32 =>
-    square_of_sums() - sum_of_squares()
+  fun difference(n: USize): USize =>
+    square_of_sums(n) - sum_of_squares(n)

data/tracks/pony/exercises/difference-of-squares/test.pony

@@ -4,28 +4,21 @@ actor Main is TestList
   new create(env: Env) =>
     PonyTest(env, this)
 
-  new make() =>
-    None
-
   fun tag tests(test: PonyTest) =>
     test(_TestSquares)
 
 class iso _TestSquares is UnitTest
-  """
-  Test Difference of Squares package
-  """
-
   fun name(): String => "difference-of-squares/Squares"
 
   fun apply(h: TestHelper) =>
-    h.assert_eq[U32](225, Squares(5).square_of_sums())
-    h.assert_eq[U32](55, Squares(5).sum_of_squares())
-    h.assert_eq[U32](170, Squares(5).difference())
+    h.assert_eq[USize](225, Squares.square_of_sums(5))
+    h.assert_eq[USize](55, Squares.sum_of_squares(5))
+    h.assert_eq[USize](170, Squares.difference(5))
 
-    h.assert_eq[U32](3025, Squares(10).square_of_sums())
-    h.assert_eq[U32](385, Squares(10).sum_of_squares())
-    h.assert_eq[U32](2640, Squares(10).difference())
+    h.assert_eq[USize](3025, Squares.square_of_sums(10))
+    h.assert_eq[USize](385, Squares.sum_of_squares(10))
+    h.assert_eq[USize](2640, Squares.difference(10))
 
-    h.assert_eq[U32](25502500, Squares(100).square_of_sums())
-    h.assert_eq[U32](338350, Squares(100).sum_of_squares())
-    h.assert_eq[U32](25164150, Squares(100).difference())
+    h.assert_eq[USize](25502500, Squares.square_of_sums(100))
+    h.assert_eq[USize](338350, Squares.sum_of_squares(100))
+    h.assert_eq[USize](25164150, Squares.difference(100))

data/tracks/pony/exercises/hamming/example.pony

@@ -1,26 +1,11 @@
 use "collections"
+use "itertools"
 
-class Hamming
-  let _name: String
-
-  new create() =>
-    _name = "Hamming"
-
-  fun apply(strand1: String, strand2: String): U8 ? =>
+primitive HammingDistance
+  fun apply(strand1: String, strand2: String): USize ? =>
     if (strand1.size() != strand2.size()) then error end
-
-    compute_distance(strand1, strand2)
-
-  fun compute_distance(strand1: String, strand2: String): U8 ? =>
-    let size: USize = strand1.size()
-    var dist: U8 = U8(0)
-    var idx: ISize = 0
-
-    while idx < size.isize() do
-      if (strand1.at_offset(idx).ne(strand2.at_offset(idx))) then
-        dist = dist + 1
-      end
-      idx = idx + 1
-    end
-
-    dist
+    
+    Iter[U8](strand1.values())
+      .zip[U8](strand2.values())
+      .filter({(t: (U8, U8)): Bool => t._1 != t._2})
+      .count()

data/tracks/pony/exercises/hamming/test.pony

@@ -4,37 +4,23 @@ actor Main is TestList
   new create(env: Env) =>
     PonyTest(env, this)
 
-  new make() =>
-    None
-
   fun tag tests(test: PonyTest) =>
-    test(_HammingDistanceTest)
-    test(_HammingParamTest)
-
-class iso _HammingDistanceTest is UnitTest
-  """
-  Test Hamming package returns the right distance
-  """
-  fun name(): String => "hamming/Hamming"
+    test(_TestHammingDistance)
 
-  fun apply(h: TestHelper): None ? =>
-    h.assert_eq[U8](0, Hamming("A", "A"))
-    h.assert_eq[U8](0, Hamming("GGACTGA", "GGACTGA"))
-    h.assert_eq[U8](1, Hamming("A", "G"))
-    h.assert_eq[U8](2, Hamming("AG", "CT"))
-    h.assert_eq[U8](1, Hamming("AT", "CT"))
-    h.assert_eq[U8](1, Hamming("GGACG", "GGTCG"))
-    h.assert_eq[U8](2, Hamming("ACCAGGG", "ACTATGG"))
-    h.assert_eq[U8](1, Hamming("AGG", "AGA"))
-    h.assert_eq[U8](4, Hamming("GATACA", "GCATAA"))
-    h.assert_eq[U8](9, Hamming("GGACGGATTCTG", "AGGACGGATTCT"))
+class iso _TestHammingDistance is UnitTest
+  fun name(): String => "hamming/HammingDistance"
 
- class iso _HammingParamTest is UnitTest
-  """
-  Test Hamming package returns the right distance
-  """
-  fun name(): String => "hamming/Hamming"
+  fun apply(h: TestHelper) ? =>
+    h.assert_eq[USize](0, HammingDistance("A", "A"))
+    h.assert_eq[USize](0, HammingDistance("GGACTGA", "GGACTGA"))
+    h.assert_eq[USize](1, HammingDistance("A", "G"))
+    h.assert_eq[USize](2, HammingDistance("AG", "CT"))
+    h.assert_eq[USize](1, HammingDistance("AT", "CT"))
+    h.assert_eq[USize](1, HammingDistance("GGACG", "GGTCG"))
+    h.assert_eq[USize](2, HammingDistance("ACCAGGG", "ACTATGG"))
+    h.assert_eq[USize](1, HammingDistance("AGG", "AGA"))
+    h.assert_eq[USize](4, HammingDistance("GATACA", "GCATAA"))
+    h.assert_eq[USize](9, HammingDistance("GGACGGATTCTG", "AGGACGGATTCT"))
 
-  fun apply(h: TestHelper) =>
-    h.assert_error({()? => Hamming("GAT", "GA")})
-    h.assert_error({()? => Hamming("GA", "GAC")})
+    h.assert_error({()? => HammingDistance("GAT", "GA")})
+    h.assert_error({()? => HammingDistance("GA", "GAC")})

data/tracks/pony/exercises/hello-world/example.pony

@@ -1,9 +1,3 @@
-class HelloWorld
-
-  let hello: String
-
-  new create() =>
-    hello  = "Hello, "
-
-  fun say_hello(who: String = "World"): String =>
-    hello.add(who + "!")
+primitive HelloWorld
+  fun hello(name: String = "World"): String =>
+    "Hello, " + name + "!"

data/tracks/pony/exercises/hello-world/test.pony

@@ -4,21 +4,12 @@ actor Main is TestList
   new create(env: Env) =>
     PonyTest(env, this)
 
-  new make() =>
-    None
-
   fun tag tests(test: PonyTest) =>
     test(_TestHelloWorld)
 
 class iso _TestHelloWorld is UnitTest
-  """
-  Test HelloWorld package
-  """
   fun name(): String => "hello-world/HelloWorld"
 
   fun apply(h: TestHelper) =>
-    let hello: HelloWorld = HelloWorld.create()
-
-    h.assert_eq[String]("Hello, World!", hello.say_hello())
-    h.assert_eq[String]("Hello, Exercism!", hello.say_hello("Exercism"))
-
+    h.assert_eq[String]("Hello, World!", HelloWorld.hello())
+    h.assert_eq[String]("Hello, Exercism!", HelloWorld.hello("Exercism"))

data/tracks/pony/exercises/leap/example.pony

@@ -1,10 +1,4 @@
-class Leap
-
-  fun apply(year: U32): Bool =>
-    if (year % 400) == 0 then
-      true
-    elseif ((year % 100) != 0) and ((year % 4) == 0) then
-      true
-    else
-      false
-    end
+primitive Leap
+  fun apply(year: USize): Bool =>
+    let has_factor = {(n: USize)(year): Bool => (year % n) == 0}
+    has_factor(4) and (not has_factor(100) or has_factor(400))

data/tracks/pony/exercises/leap/test.pony

@@ -4,22 +4,13 @@ actor Main is TestList
   new create(env: Env) =>
     PonyTest(env, this)
 
-  new make() =>
-    None
-
   fun tag tests(test: PonyTest) =>
-    test(_LeapTest)
+    test(_TestLeap)
 
-class iso _LeapTest is UnitTest
-  """
-  Test Leap package
-  """
+class iso _TestLeap is UnitTest
   fun name(): String => "leap/Leap"
 
   fun apply(h: TestHelper) =>
-    // Note -> Current master-branch simplifies these functions to
-    // assert_true/false, and removes expect
-    // https://github.com/ponylang/ponyc/blob/master/packages/ponytest/helper.pony
     h.assert_true(Leap(1996), "Testing a leap year")
     h.assert_false(Leap(1997), "Testing an odd year")
     h.assert_false(Leap(1998), "Testing a non-leap even year")

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

@@ -30,11 +30,10 @@ module Generator
     end
 
     def repository
-      if @options[:verbose]
-        LoggingRepository.new(paths: @paths, exercise_name: @options[:exercise_name], logger: logger)
-      else
-        Repository.new(paths: @paths, exercise_name: @options[:exercise_name])
-      end
+      LoggingRepository.new(
+        repository: Repository.new(paths: @paths, exercise_name: @options[:exercise_name]),
+        logger: logger
+      )
     end
 
     def parse_options(args)
@@ -46,7 +45,7 @@ module Generator
     def logger
       logger = Logger.new($stdout)
       logger.formatter = proc { |_severity, _datetime, _progname, msg| "#{msg}\n" }
-      logger.level = @options[:verbose] ? Logger::DEBUG : Logger::ERROR
+      logger.level = @options[:verbose] ? Logger::DEBUG : Logger::INFO
       logger
     end