trackler 2.2.1.157 → 2.2.1.158

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79b12156e5d0f03cc7198761a82d88d046b5f819
-  data.tar.gz: a32e3ae82cc87bf51b4830a0dd6a4249902688ef
+  metadata.gz: b019b44614dd8458a6088690169a84299df130ff
+  data.tar.gz: 0a622165cb86a6b6c703b5e662e73c3e8ab31599
 SHA512:
-  metadata.gz: 03b5c2d43e94f9a8deba02c6cac9fbcd65ca915720aa7656d520bf8a22f299c4fb90152c36a7c58a19ad929eb1e268b97fda8de8fc32ff4f3cf07a35a0eae7a2
-  data.tar.gz: 4c2c083aeb4c851ce566f2eddcb3a60e9ae05ef1321fd0025b06d396b14a486a5e211ddda71256cf9188dc651ba0b209815b8957c7b3318956a68a30afe247bf
+  metadata.gz: 7196c114c4b5606872ce6da898d557622c437b433fc2b503c84c9b647d93e62baa44357e6251493cf779e3b595ce38179f23e54c487731ad1cce056199ec11f4
+  data.tar.gz: 729f6daa031098a10aed27b29fab879165e2550b2b7b3330b6ced4fa481ca77959b9da6f8c3d6d16318eb99c11c34405601bb930292effd6d08b36efd1013219

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.157"
+  VERSION = "2.2.1.158"
 end

data/tracks/reasonml/.gitignore

@@ -2,3 +2,4 @@
 .DS_Store
 bin/configlet
 bin/configlet.exe
+.vscode

data/tracks/ruby/config.json

@@ -4,7 +4,6 @@
   "blurb": "Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.",
   "gitter": "ruby",
   "solution_pattern": "[Ee]xample|\\.meta/solutions/[^/]*\\.rb",
-  "foregone": [],
   "exercises": [
     {
       "slug": "hello-world",
@@ -733,16 +732,26 @@
     {
       "slug": "octal",
       "uuid": "cae4e000-3aac-41f7-b727-f9cce12d058d",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 0,
+      "topics": null,
       "deprecated": true
     },
     {
       "slug": "point-mutations",
       "uuid": "89bd3d71-000f-4cd9-9a84-ad1b22ddbd33",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 0,
+      "topics": null,
       "deprecated": true
     },
     {
       "slug": "complex-numbers",
       "uuid": "d75bd7c0-52c5-44f2-a046-f63cb332425f",
+      "core": false,
+      "unlocked_by": null,
       "difficulty": 3,
       "topics": [
         "mathematics"
@@ -770,6 +779,16 @@
         "logic",
         "loops"
       ]
+    },
+    {
+      "uuid": "239b8e79-2983-4ce0-9dda-9bb999e79d11",
+      "slug": "zipper",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 7,
+      "topics": [
+        "Data Structures"
+      ]
     }
   ]
-}
+}

data/tracks/ruby/config/maintainers.json

@@ -1,64 +1,65 @@
 {
+  "docs_url": "",
   "maintainers": [
     {
-      "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
       "github_username": "kotp",
+      "alumnus": false,
+      "show_on_website": false,
+      "name": null,
       "link_text": null,
       "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "avatar_url": null,
+      "bio": null
     },
     {
-      "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
       "github_username": "bernardoamc",
+      "alumnus": false,
+      "show_on_website": false,
+      "name": null,
       "link_text": null,
       "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "avatar_url": null,
+      "bio": null
     },
     {
-      "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
       "github_username": "tommyschaefer",
+      "alumnus": false,
+      "show_on_website": false,
+      "name": null,
       "link_text": null,
       "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "avatar_url": null,
+      "bio": null
     },
     {
-      "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
       "github_username": "hilary",
+      "alumnus": false,
+      "show_on_website": false,
+      "name": null,
       "link_text": null,
       "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "avatar_url": null,
+      "bio": null
     },
     {
-      "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
       "github_username": "bmulvihill",
+      "alumnus": false,
+      "show_on_website": false,
+      "name": null,
       "link_text": null,
       "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "avatar_url": null,
+      "bio": null
     },
     {
-      "alumnus": false,
-      "avatar_url": null,
-      "bio": null,
       "github_username": "Insti",
+      "alumnus": false,
+      "show_on_website": false,
+      "name": null,
       "link_text": null,
       "link_url": null,
-      "name": null,
-      "show_on_website": false
+      "avatar_url": null,
+      "bio": null
     }
   ]
-}
+}

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

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

data/tracks/ruby/exercises/zipper/.meta/generator/zipper_case.rb

@@ -0,0 +1,107 @@
+require 'generator/exercise_case'
+
+class ZipperCase < Generator::ExerciseCase
+  def workload
+    body = [
+      "#{initial_tree}\n",
+      "zipper = Zipper.from_tree(tree)\n",
+      "value = #{operations(input)}\n",
+      "#{expected_by_type}\n",
+      assertion
+    ]
+    indent(body, 4)
+  end
+
+  private
+
+    def initial_tree
+      indent([ 
+        "tree =\n",
+        build_tree(input['initialTree'])
+      ], 6)
+    end
+
+    def operations(input, zipper_name='zipper')
+      operation_chain = input['operations'].map do |op|
+        operation = op['operation']
+        item = op['item']
+
+        set_tree = lambda do
+          if item.nil?
+            "#{operation}(nil)"
+          else
+            depth = ' ' * 6
+            left = nil_if build_tree(item['left'], 5)
+            right = nil_if build_tree(item['right'], 5)
+            # I know. This line is crazy.
+            "#{operation}(\n#{depth}Node.new(#{item['value']},\n  #{depth}#{left},\n  #{depth}#{right}))"
+          end
+        end
+
+        case operation
+        when 'set_value'
+          "#{operation}(#{op['item']})"
+        when 'set_left'
+          set_tree.call
+        when 'set_right'
+          set_tree.call
+        else
+          operation
+        end
+      end.join('.')
+      "#{zipper_name}.%s" % operation_chain
+    end
+
+    def assertion
+      if expected['value'].nil? && expected['initialTree'].nil?
+        'assert_nil value'
+      else
+        'assert_equal expected, value'
+      end
+    end
+
+    def expected_by_type
+      case expected['type']
+      when 'tree'
+        indent([
+          "expected = \n",
+          build_tree(expected['value'])
+        ], 6)
+      when 'int'
+        "expected = #{expected['value']}"
+      when 'zipper'
+        if expected['initialTree']
+          indent([
+            "expected_tree =\n  ",
+            "#{build_tree(expected['initialTree'])}\n",
+            "expected_zipper = Zipper.from_tree(expected_tree)\n",
+            "expected = #{operations(expected, 'expected_zipper')}" 
+          ], 4)
+        elsif expected['value'].nil?
+          "expected = nil"
+        end
+      end
+    end
+
+    def build_tree(input, depth=4)
+      return 'nil' if input.nil?
+      next_depth = depth + 1
+      tree = 
+        "Node.new(#{input['value']},\n",
+        "#{build_tree(input['left'], next_depth)},\n",
+        "#{build_tree(input['right'], next_depth)})"
+      indent(tree, depth * 2)
+    end
+
+    def indent(lines, spaces)
+      lines.join(' ' * spaces)
+    end
+
+    def nil_if(value)
+      if value.nil?
+        'nil'
+      else
+        value
+      end
+    end
+end

data/tracks/ruby/exercises/zipper/.meta/solutions/zipper.rb

@@ -0,0 +1,82 @@
+module BookKeeping
+  VERSION = 71
+end
+
+Node = Struct.new(:value, :left, :right)
+
+Crumb = Struct.new(:direction, :value, :tree)
+
+class Zipper
+  attr_reader :value
+
+  def initialize(value, left, right, crumbs=[])
+    @value = value
+    @left = left
+    @right = right
+    @crumbs = crumbs
+  end
+
+  def self.from_tree(tree)
+    Zipper.new(tree.value, tree.left, tree.right)
+  end
+
+  def to_tree
+    tree = Node.new(value, @left, @right)
+    for crumb in @crumbs
+      case crumb.direction
+      when :left
+        tree = Node.new(crumb.value, tree.dup, crumb.tree)
+      when :right
+        tree = Node.new(crumb.value, crumb.tree, tree.dup)
+      end
+    end
+    tree
+  end
+
+  def left
+    return nil if @left.nil?
+    crumbs = [Crumb.new(:left, value, @right)] + @crumbs
+    Zipper.new(@left.value, @left.left, @left.right, crumbs)
+  end
+
+  def right
+    return nil if @right.nil?
+    crumbs = [Crumb.new(:right, value, @left)] + @crumbs
+    Zipper.new(@right.value, @right.left, @right.right, crumbs)
+  end
+
+  def up
+    crumb = @crumbs.first
+    return nil if crumb.nil?
+    remaining_crumbs = @crumbs.drop(1)
+    case crumb.direction
+    when :left
+      Zipper.new(crumb.value,
+                 Node.new(value, @left, @right),
+                 crumb.tree,
+                 remaining_crumbs)
+    when :right
+      Zipper.new(crumb.value,
+                 crumb.tree,
+                 Node.new(value, @left, @right),
+                 remaining_crumbs)
+    end
+  end
+
+  def set_value(new_value)
+    Zipper.new(new_value, @left, @right, @crumbs)
+  end
+
+  def set_left(node)
+    Zipper.new(value, node, @right, @crumbs)
+  end
+
+  def set_right(node)
+    Zipper.new(value, @left, node, @crumbs)
+  end
+
+  def ==(other_zipper)
+    return false unless other_zipper.is_a? Zipper
+    to_tree == other_zipper.to_tree
+  end
+end

data/tracks/ruby/exercises/zipper/README.md

@@ -0,0 +1,54 @@
+# Zipper
+
+Creating a zipper for a binary tree.
+
+[Zippers](https://en.wikipedia.org/wiki/Zipper_%28data_structure%29) are
+a purely functional way of navigating within a data structure and
+manipulating it.  They essentially contain a data structure and a
+pointer into that data structure (called the focus).
+
+For example given a rose tree (where each node contains a value and a
+list of child nodes) a zipper might support these operations:
+
+- `from_tree` (get a zipper out of a rose tree, the focus is on the root node)
+- `to_tree` (get the rose tree out of the zipper)
+- `value` (get the value of the focus node)
+- `prev` (move the focus to the previous child of the same parent,
+  returns a new zipper)
+- `next` (move the focus to the next child of the same parent, returns a
+  new zipper)
+- `up` (move the focus to the parent, returns a new zipper)
+- `set_value` (set the value of the focus node, returns a new zipper)
+- `insert_before` (insert a new subtree before the focus node, it
+  becomes the `prev` of the focus node, returns a new zipper)
+- `insert_after` (insert a new subtree after the focus node, it becomes
+  the `next` of the focus node, returns a new zipper)
+- `delete` (removes the focus node and all subtrees, focus moves to the
+  `next` node if possible otherwise to the `prev` node if possible,
+  otherwise to the parent node, returns a new zipper)
+
+* * * *
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/ruby).
+
+For running the tests provided, you will need the Minitest gem. Open a
+terminal window and run the following command to install minitest:
+
+    gem install minitest
+
+If you would like color output, you can `require 'minitest/pride'` in
+the test file, or note the alternative instruction, below, for running
+the test file.
+
+Run the tests from the exercise directory using the following command:
+
+    ruby zipper_test.rb
+
+To include color from the command line:
+
+    ruby -r minitest/pride zipper_test.rb
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/ruby/exercises/zipper/zipper_test.rb

@@ -0,0 +1,358 @@
+require 'minitest/autorun'
+require_relative 'zipper'
+
+# Common test data version: 1.1.0 6fb5601
+class ZipperTest < Minitest::Test
+  def test_data_is_retained
+    # skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.to_tree
+    expected = 
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    assert_equal expected, value
+  end
+
+  def test_left_right_and_value
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.right.value
+    expected = 3
+    assert_equal expected, value
+  end
+
+  def test_dead_end
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.left
+    expected = nil
+    assert_nil value
+  end
+
+  def test_tree_from_deep_focus
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.right.to_tree
+    expected = 
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    assert_equal expected, value
+  end
+
+  def test_traversing_up_from_top
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.up
+    expected = nil
+    assert_nil value
+  end
+
+  def test_left_right_and_up
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.up.right.up.left.right.value
+    expected = 3
+    assert_equal expected, value
+  end
+
+  def test_set_value
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.set_value(5).to_tree
+    expected = 
+      Node.new(1,
+        Node.new(5,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    assert_equal expected, value
+  end
+
+  def test_set_value_after_traversing_up
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.right.up.set_value(5).to_tree
+    expected = 
+      Node.new(1,
+        Node.new(5,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    assert_equal expected, value
+  end
+
+  def test_set_left_with_leaf
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.set_left(
+      Node.new(5,
+        nil,
+        nil)).to_tree
+    expected = 
+      Node.new(1,
+        Node.new(2,
+          Node.new(5,
+            nil,
+            nil),
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    assert_equal expected, value
+  end
+
+  def test_set_right_with_null
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.set_right(nil).to_tree
+    expected = 
+      Node.new(1,
+        Node.new(2,
+          nil,
+          nil),
+        Node.new(4,
+          nil,
+          nil))
+    assert_equal expected, value
+  end
+
+  def test_set_right_with_subtree
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.set_right(
+      Node.new(6,
+        Node.new(7,
+          nil,
+          nil),
+        Node.new(8,
+          nil,
+          nil))).to_tree
+    expected = 
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(6,
+          Node.new(7,
+            nil,
+            nil),
+          Node.new(8,
+            nil,
+            nil)))
+    assert_equal expected, value
+  end
+
+  def test_set_value_on_deep_focus
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.right.set_value(5).to_tree
+    expected = 
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(5,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    assert_equal expected, value
+  end
+
+  def test_different_paths_to_same_zipper
+    skip
+    tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    zipper = Zipper.from_tree(tree)
+    value = zipper.left.up.right
+    expected_tree =
+      Node.new(1,
+        Node.new(2,
+          nil,
+          Node.new(3,
+            nil,
+            nil)),
+        Node.new(4,
+          nil,
+          nil))
+    expected_zipper = Zipper.from_tree(expected_tree)
+    expected = expected_zipper.right
+    assert_equal expected, value
+  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, which may be placed near the end of your file.
+  #
+  # 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_bookkeeping
+    skip
+    assert_equal 71, BookKeeping::VERSION
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.157
+  version: 2.2.1.158
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-08 00:00:00.000000000 Z
+date: 2018-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -12932,6 +12932,11 @@ files:
 - tracks/ruby/exercises/wordy/.meta/solutions/wordy.rb
 - tracks/ruby/exercises/wordy/README.md
 - tracks/ruby/exercises/wordy/wordy_test.rb
+- tracks/ruby/exercises/zipper/.meta/.version
+- tracks/ruby/exercises/zipper/.meta/generator/zipper_case.rb
+- tracks/ruby/exercises/zipper/.meta/solutions/zipper.rb
+- tracks/ruby/exercises/zipper/README.md
+- tracks/ruby/exercises/zipper/zipper_test.rb
 - tracks/ruby/img/icon.png
 - tracks/ruby/lib/bookkeeping.md
 - tracks/ruby/lib/disable_skip.rb