trackler 2.0.5.13 → 2.0.5.14

data/tracks/php/exercises/variable-length-quantity/variable-length-quantity_test.php

@@ -122,7 +122,7 @@ class VariableLengthQuantityTest extends PHPUnit_Framework_TestCase
 
         $this->setExpectedException(OverflowException::class);
 
-        vlq_decode([0xff, 0xff, 0xff, 0xff, 0xff]);
+        vlq_decode([0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]);
     }
 
     public function testChainedDecodeEncodeGivesOriginalBytes()

data/tracks/ruby/Gemfile

@@ -1,7 +1,6 @@
 source 'https://rubygems.org'
 
 gem 'minitest'
-gem 'rainbow', '>= 2.1.0', '< 2.2.0'
 gem 'rubocop', '0.36.0'
 gem 'simplecov'
 gem 'rake'

data/tracks/ruby/Makefile

@@ -1,3 +1,5 @@
+.PHONY: test
+
 # assignments
 ASSIGNMENT ?= ""
 IGNOREDIRS := "^(\.git|bin|docs|lib|exercises)$$"
@@ -33,4 +35,3 @@ test:
 	@for assignment in $(ASSIGNMENTS); do \
 		ASSIGNMENT=$$assignment $(MAKE) -s test-assignment || exit 1;\
 	done
-

data/tracks/ruby/Rakefile

@@ -1,6 +1,9 @@
 require 'rake'
 require 'rake/testtask'
 
+desc 'rake with no argument will run "rake test"'
+task default: :test
+
 Rake::TestTask.new do |task|
   task.pattern = 'test/*_test.rb'
 end

data/tracks/ruby/exercises/simple-linked-list/.meta/.version

@@ -0,0 +1 @@
+1

data/tracks/ruby/exercises/simple-linked-list/example.rb

@@ -1,68 +1,59 @@
 class Element
-  attr_reader   :datum
+  attr_reader :datum
   attr_accessor :next
-
-  def initialize(datum, next_element=nil)
-    @datum = datum
-    @next  = next_element
-  end
-
-  def tail?
-    @next.nil?
+  def initialize(value)
+    @datum = value
+    @next  = nil
   end
 end
 
 class SimpleLinkedList
-  attr_reader :size
-  attr_reader :head
-
-  def initialize
-    @head = nil
-    @size = 0
+  def initialize(array = [])
+    create_from_array(array)
   end
 
-  def push(datum)
-    e = Element.new(datum, @head)
-    @head = e
-    @size += 1
-  end
-
-  def empty?
-    @size.zero?
+  def to_a
+    result = []
+    pointer = @head
+    while pointer
+      result << pointer.datum
+      pointer = pointer.next
+    end
+    result
   end
 
-  def peek
-    @head.nil? ? nil : @head.datum
+  def push(element)
+    element.next = @head unless @head.nil?
+    @head = element
+    self
   end
 
   def pop
-    e, @head = @head, @head.next
-    @size -= 1
-    return e.datum
-  end
-
-  def each
-    return enum_for(:each) unless block_given?
-    current = head
-    until current.nil?
-      yield current.datum
-      current = current.next
+    element = @head
+    @head = element.next if element
+    element
+  end
+
+  def reverse!
+    previous = nil
+    pointer = @head
+    while pointer
+      temp = pointer.next
+      pointer.next = previous
+      previous = pointer
+      pointer = temp
     end
+    @head = previous
+    self
   end
 
-  def to_a
-    each.to_a
-  end
+  private
 
-  def reverse
-    each.with_object(SimpleLinkedList.new) { |datum, list| list.push(datum) }
+  def create_from_array(array)
+    array.each { |value| push(Element.new(value)) }
   end
+end
 
-  def self.from_a(a)
-    new.tap do |list|
-      a.to_a.reverse_each do |item|
-        list.push(item)
-      end
-    end
-  end
+module BookKeeping
+  VERSION = 1
 end

data/tracks/ruby/exercises/simple-linked-list/simple_linked_list_test.rb

@@ -1,189 +1,163 @@
-#!/usr/bin/env ruby
-gem 'minitest', '>= 5.0.0'
 require 'minitest/autorun'
-
 require_relative 'simple_linked_list'
 
 class LinkedListTest < Minitest::Test
-  def test_element_datum
-    e = Element.new(1)
-    assert_equal 1, e.datum
-  end
-
-  def test_element_tail
-    skip
-    e = Element.new(1)
-    assert e.tail?
+  def test_element
+    element = Element.new(1)
+    assert_equal 1, element.datum
   end
 
-  def test_element_next_default
+  def test_element_can_hold_a_different_value
     skip
-    e = Element.new(1)
-    assert_nil e.next
+    element = Element.new(10)
+    assert_equal 10, element.datum
   end
 
-  def test_element_next_initialization
+  def test_element_next
     skip
-    e1 = Element.new(1)
-    e2 = Element.new(2, e1)
-    assert_equal e1, e2.next
+    element = Element.new(1)
+    assert_nil element.next
   end
 
-  def test_empty_list_size
+  def test_element_next_can_be_assigned_to
     skip
-    l = SimpleLinkedList.new
-    assert_equal 0, l.size
+    first  = Element.new(1)
+    second = Element.new(2)
+    first.next = second
+    assert_equal second, first.next
   end
 
-  def test_empty_list_empty
+  def test_list_push
     skip
-    l = SimpleLinkedList.new
-    assert l.empty?
+    list = SimpleLinkedList.new
+    element = Element.new(1)
+    assert_equal list, list.push(element)
   end
 
-  def test_pushing_element_on_list
+  def test_list_pop
     skip
-    l = SimpleLinkedList.new
-    l.push(1)
-    assert_equal 1, l.size
+    list = SimpleLinkedList.new
+    element = Element.new(1)
+    list.push(element)
+    assert_equal element, list.pop
   end
 
-  def test_empty_list_1_element
+  def test_list_pop_empty
     skip
-    l = SimpleLinkedList.new
-    l.push(1)
-    refute l.empty?
+    list = SimpleLinkedList.new
+    assert_nil list.pop
   end
 
-  def test_peeking_at_list
+  def test_list_pop_is_last_in_first_out
     skip
-    l = SimpleLinkedList.new
-    l.push(1)
-    assert_equal 1, l.size
-    assert_equal 1, l.peek
+    list = SimpleLinkedList.new
+    first = Element.new(1)
+    second = Element.new(2)
+    list.push(first).push(second)
+    assert_equal second, list.pop
   end
 
-  def test_peeking_at_empty_list
+  def test_list_empty_to_array
     skip
-    l = SimpleLinkedList.new
-    assert_nil l.peek
+    list = SimpleLinkedList.new
+    assert_equal [], list.to_a
   end
 
-  def test_access_head_element
+  def test_list_single_to_array
     skip
-    l = SimpleLinkedList.new
-    l.push(1)
-    assert_instance_of Element, l.head
-    assert_equal 1, l.head.datum
-    assert l.head.tail?
+    list = SimpleLinkedList.new
+    first = Element.new(1)
+    list.push(first)
+    assert_equal [1], list.to_a
   end
 
-  def test_items_are_stacked
+  def test_list_multiple_to_array
     skip
-    l = SimpleLinkedList.new
-    l.push(1)
-    l.push(2)
-    assert_equal 2, l.size
-    assert_equal 2, l.head.datum
-    assert_equal 1, l.head.next.datum
+    list = SimpleLinkedList.new
+    first = Element.new(1)
+    second = Element.new(2)
+    third = Element.new(3)
+    list.push(first).push(second).push(third)
+    assert_equal [3,2,1], list.to_a
   end
 
-  def test_push_10_items
+  def test_list_create_from_array
     skip
-    l = SimpleLinkedList.new
-    (1..10).each do |datum|
-      l.push(datum)
-    end
-    assert_equal 10, l.size
-    assert_equal 10, l.peek
+    array = [1,2,3]
+    list = SimpleLinkedList.new(array)
+    assert_equal [3,2,1], list.to_a
   end
 
-  def test_pop_1_item
+  def test_list_created_from_array_still_made_up_of_elements
     skip
-    l = SimpleLinkedList.new
-    l.push(1)
-    assert_equal 1, l.pop
-    assert_equal 0, l.size
+    array = [1,2,3]
+    list = SimpleLinkedList.new(array)
+    assert_equal Element, list.pop.class
   end
 
-  def test_popping_frenzy
+  def test_list_from_array_still_acts_as_lifo
     skip
-    l = SimpleLinkedList.new
-    (1..10).each do |datum|
-      l.push(datum)
-    end
-    6.times { l.pop }
-    assert_equal 4, l.size
-    assert_equal 4, l.peek
+    array = [1,2,3]
+    list = SimpleLinkedList.new(array)
+    element = list.pop
+    assert_equal 3, element.datum
   end
 
-  def test_from_a_empty_array
+  def test_list_in_place_reverse!
     skip
-    l = SimpleLinkedList.from_a([])
-    assert_equal 0, l.size
-    assert_nil l.peek
-  end
-
-  def test_from_a_nil
-    skip
-    l = SimpleLinkedList.from_a(nil)
-    assert_equal 0, l.size
-    assert_nil l.peek
-  end
+    first = Element.new(1)
+    second = Element.new(2)
+    third = Element.new(3)
+    list = SimpleLinkedList.new
+    list.push(first).push(second).push(third)
 
-  def test_from_a_2_element_array
-    skip
-    l = SimpleLinkedList.from_a([1, 2])
-    assert_equal 2, l.size
-    assert_equal 1, l.peek
-    assert_equal 2, l.head.next.datum
+    assert_equal [1,2,3], list.reverse!.to_a
   end
 
-  def test_from_a_10_items
+  def test_list_in_place_reverse_are_the_same_elements
     skip
-    l = SimpleLinkedList.from_a((1..10).to_a)
-    assert_equal 10, l.size
-    assert_equal 1, l.peek
-    assert_equal 10, l.head.next.next.next.next.next.next.next.next.next.datum
-  end
+    first = Element.new(1)
+    second = Element.new(2)
+    list = SimpleLinkedList.new
+    list.push(first).push(second)
 
-  def test_to_a_empty_list
-    skip
-    l = SimpleLinkedList.new
-    assert_equal [], l.to_a
-  end
+    list.reverse!
 
-  def test_to_a_of_1_element_list
-    skip
-    assert_equal [1], SimpleLinkedList.from_a([1]).to_a
+    assert_equal first, list.pop
+    assert_equal second, list.pop
   end
 
-  def test_to_a_of_2_element_list
+  def test_list_reverse_empty_list
     skip
-    assert_equal [1, 2], SimpleLinkedList.from_a([1, 2]).to_a
+    list = SimpleLinkedList.new
+    assert_equal list, list.reverse!
   end
 
-  def test_reverse_2_element_list
+  def test_works_for_1_through_10
     skip
-    list = SimpleLinkedList.from_a([1, 2])
-    # list_r and list need not be the same object
-    list_r = list.reverse
-
-    assert_equal 2, list_r.peek
-    assert_equal 1, list_r.head.next.datum
-    assert list_r.head.next.tail?
+    list = SimpleLinkedList.new(1..10)
+    expected = [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+    assert_equal expected, list.to_a
   end
 
-  def test_reverse_10_element_list
-    skip
-    data = (1..10).to_a
-    list = SimpleLinkedList.from_a(data)
-    assert_equal data.reverse, list.reverse.to_a
-  end
+  # Problems in exercism evolve over time, as we find better ways to ask
+  # questions.
+  # The version number refers to the version of the problem you solved,
+  # not your solution.
+  #
+  # Define a constant named VERSION inside of the top level BookKeeping
+  # module.
+  #  In your file, it will look like this:
+  #
+  # module BookKeeping
+  #   VERSION = 1 # Where the version number matches the one in the test.
+  # end
+  #
+  # If you are curious, read more about constants on RubyDoc:
+  # http://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/constants.html
 
-  def test_roundtrip_10_element_array
+  def test_bookkeeping
     skip
-    data = (1..10).to_a
-    assert_equal data, SimpleLinkedList.from_a(data).to_a
+    assert_equal 1, BookKeeping::VERSION
   end
 end

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

@@ -0,0 +1 @@
+1

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

@@ -1,3 +1,7 @@
+module BookKeeping
+  VERSION = 1
+end
+
 class WordProblem
   attr_reader :question
   def initialize(question)