forester 3.2.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a57950cecbc75dfde48ae961c03f72437f1e3d7
-  data.tar.gz: 31e075d6b51118542e5a8e0dbca61aee3735e6c4
+  metadata.gz: c4bc0ddc9aa53d1bdab802726bbdc14871584d67
+  data.tar.gz: d43910fab0a17df6bee538e7822a68faba3616b0
 SHA512:
-  metadata.gz: 5f2453667e82901bfd5ce7ba63222262319ec772d3b9e9092d806dbf2eafdb5c57de7d2b737316aed1c8ce647e1b6aecfaf4c0292f571595dc7aabda673d828b
-  data.tar.gz: 3e02c63d56490f50801b65a085b38407d53d31e725a9e52330cb4c42d0813ac9d02a673172b4ca1c2eb5c4c2eaf8371471688e3b67aa9ef33692310a7a446388
+  metadata.gz: 58c9d3199133b793ffc19f7a40dd85b37a6e93e4595b06c974447f091f274c77433d9be1df9291116cf2ba240b49178ab6813766fac65ddabf40f5176341ebd3
+  data.tar.gz: 05ca996da70214bfb0e5ba33db69ae8d7782b7955fbff7d72893df50ab99a70e9a13a01f92adfe3a94839bc53ff47cb96691b010b12c5625f224083814bb4f0d

data/Rakefile

@@ -5,4 +5,4 @@ Rake::TestTask.new do |t|
 end
 
 desc "Run tests"
-task :default => :test
+task :default => :test

data/forester.gemspec

@@ -6,7 +6,7 @@ require 'forester/version'
 Gem::Specification.new do |s|
   s.name        = 'forester'
   s.version     = Forester::Version
-  s.date        = '2016-08-22'
+  s.date        = '2016-08-27'
   s.summary     = "A gem to represent and interact with tree data structures"
   s.description = "Based on rubytree, this gem lets you build trees and run queries against them."
   s.authors     = ["Eugenio Bruno"]
@@ -27,4 +27,4 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'minitest', ['~> 5.9']
   s.add_development_dependency 'pry-byebug', ['~> 3.4']
 
-end
+end

data/lib/forester/node_content/base.rb

@@ -6,4 +6,4 @@ module Forester
 
     end
   end
-end
+end

data/lib/forester/node_content/dictionary.rb

@@ -87,4 +87,4 @@ module Forester
 
     end
   end
-end
+end

data/lib/forester/node_content/factory.rb

@@ -24,4 +24,4 @@ module Forester
 
     end
   end
-end
+end

data/lib/forester/node_content/list.rb

@@ -28,4 +28,4 @@ module Forester
 
     end
   end
-end
+end

data/lib/forester/tree_factory.rb

@@ -3,45 +3,72 @@ module Forester
 
     class << self
 
-      def from_yaml_file(file)
+      def from_yaml_file(file, options = {})
+        default_options = {
+          max_level: :last
+        }
+        options = default_options.merge(options)
+
         from_hash_with_root_key(YAML.load_file(file))
       end
 
-      def from_root_hash(hash, children_key = :children)
-        from_hash_with_root_key({ root: hash }, children_key)
+      def from_root_hash(hash, options = {})
+        default_options = {
+          max_level:    :last,
+          children_key: :children
+        }
+        options = default_options.merge(options)
+
+        from_hash_with_root_key({ root: hash }, options)
       end
 
-      def from_hash_with_root_key(hash, children_key = :children, root_key = :root)
+      def from_hash_with_root_key(hash, options = {})
+        default_options = {
+          max_level:    :last,
+          children_key: :children,
+          root_key:     :root
+        }
+        options = default_options.merge(options)
+
         dummy_root = TreeNode.new('<TEMP>')
-        real_root  = fetch_indifferently(hash, root_key)
+        real_root  = fetch_indifferently(hash, options[:root_key])
 
-        tree = with_children(dummy_root, [real_root], children_key).first_child
-        tree.detached_subtree_copy
-      end
+        max_level = options[:max_level]
+        max_level = -2 if max_level == :last
 
-      def from_hash(hash, children_key, uid = SecureRandom.uuid)
-        name = uid
-        content = NodeContent::Factory.from_hash(hash, children_key)
-        TreeNode.new(name, content)
+        tree = with_children(dummy_root, [real_root], options[:children_key], max_level + 1).first_child
+        tree.detached_subtree_copy
       end
 
-      private
+      protected
 
       def fetch_indifferently(hash, key, default = nil)
         [key, key.to_s, key.to_s.to_sym].uniq.map { |k| hash[k] }.compact.first || default || hash.fetch(root_key)
       end
 
-      def with_children(tree_node, children, children_key)
+      def with_children(tree_node, children, children_key, levels_remaining)
+        return tree_node if levels_remaining == 0
         children.each do |child|
-          child_node     = from_hash(child, children_key)
-          child_children = fetch_indifferently(child, children_key, []) # nth level
+          child_node     = node_from_hash(child, children_key)
+          child_children = fetch_indifferently(child, children_key, [])
 
-          tree_node << with_children(child_node, child_children, children_key)
+          tree_node << with_children(child_node, child_children, children_key, levels_remaining - 1)
         end
         tree_node
       end
 
+      def node_from_hash(hash, children_key, options = {})
+        default_options = {
+          uid: SecureRandom.uuid
+        }
+        options = default_options.merge(options)
+
+        name    = options[:uid]
+        content = NodeContent::Factory.from_hash(hash, children_key)
+        TreeNode.new(name, content)
+      end
+
     end
 
   end
-end
+end

data/lib/forester/tree_node.rb

@@ -8,30 +8,37 @@ module Forester
     include Mutators
     include Views
 
+    alias_method :max_level, :node_height
+    alias_method :each_node, :breadth_each
+
     def nodes_of_level(l)
-      if l.between?(0, max_level) then each_level.take(l + 1).last else [] end
+      l.between?(0, max_level) ? each_level.take(l + 1).last : []
     end
 
-    alias_method :max_level, :node_height
-
     def each_level
       Enumerator.new do |yielder|
         level = [self]
-        begin
+        until level.empty?
           yielder << level
           level = level.flat_map(&:children)
-        end until level.empty?
+        end
       end
     end
 
-    alias_method :each_node, :breadth_each
+    def get(field, options = {}, &if_missing)
+      default_options = {
+        default: :raise,
+        subtree: false
+      }
+      options = default_options.merge(options)
+
+      return own_and_descendants(field, &if_missing) if options[:subtree]
 
-    def get(field, default = :raise_error, &block)
       if has?(field)
         content.get(field)
       elsif block_given?
         yield self
-      elsif default != :raise_error
+      elsif default != :raise
         default
       else
         raise ArgumentError.new("the node \"#{name}\" does not have \"#{field}\"")
@@ -46,5 +53,16 @@ module Forester
       each_node.map(&:content)
     end
 
+    def same_as?(other)
+      return false unless content == other.content
+      return false unless    size == other.size
+      nodes_of_other = other.each_node.to_a
+      each_node.with_index do |n, i|
+        next if i == 0
+        return false unless n.same_as?(nodes_of_other[i])
+      end
+      true
+    end
+
   end
 end

data/lib/forester/tree_node_ext/aggregators.rb

@@ -1,82 +1,91 @@
 module Forester
   module Aggregators
 
-    def nodes_with(content_key, content_values)
-      each_node.select { |node| not ( Array(node.get(content_key) { :no_match }) & Array(content_values) ).empty? }
+    def own_and_descendants(field, &if_missing)
+      if_missing = -> (node) { [] } unless block_given?
+
+      flat_map { |node| Array(node.get(field, &if_missing)) }
+    end
+
+    def nodes_with(field, values, options = {})
+      default_options = {
+        single: false
+      }
+      options = default_options.merge(options)
+
+      method = options[:single] ? :find : :select
+      found_nodes = each_node.public_send(method) do |node|
+        not ( Array(node.get(field) { :no_match }) & Array(values) ).empty?
+      end
+
+      Array(found_nodes)
     end
 
     def with_ancestry(options = {})
       default_options = {
         include_root: true,
         include_self: true,
-        descending: true
+        descending:   true
       }
       options = default_options.merge(options)
 
       ancestors = self.parentage           || []
       ancestors = ancestors[0...-1]        unless options[:include_root]
       ancestors = ancestors.unshift(self)  if     options[:include_self]
-      if options[:descending] then ancestors.reverse else ancestors end
-    end
 
-    def own_and_descendants(field_name, &if_field_missing)
-      if_field_missing = -> (node) { [] } unless block_given?
-      flat_map do |node|
-        Array(node.get(field_name, &if_field_missing))
-      end
+      options[:descending] ? ancestors.reverse : ancestors
     end
 
     def search(options)
       default_options = {
-        single_node: true,
+        single_node: false,
         by_field:    :name,
         keywords:    :missing_search_keywords,
-        then_get:    :nodes,
-        of_subtree:  true,
+        then_get:    :nodes, # if :nodes, subtree is ignored
+        subtree:     true
       }
       options = default_options.merge(options)
 
-      found_nodes = nodes_with(options[:by_field], options[:keywords])
-
-      found_nodes = found_nodes.slice(0, 1) if options[:single_node]
+      found_nodes = nodes_with(options[:by_field], options[:keywords], { single: options[:single_node] } )
 
       return found_nodes if options[:then_get] == :nodes
 
       found_nodes.flat_map do |node|
-        if options[:of_subtree]
-          node.own_and_descendants(options[:then_get])
-        else
-          node.get(options[:then_get])
-        end
+        node.get(options[:then_get], { subtree: options[:subtree] })
       end
-
     end
 
-    def values_by_subtree_of_level(options = {})
+    def group_by_sibling_subtrees(options = {})
       default_options = {
-        level:                    1,
-        group_field:              'name',
-        aggregation_field:        'value',
-        if_field_missing:         -> (node) { [] },
-        include_ancestry_in_keys: false, # if false, with_root is ignored
-        with_root:                false,
+        level:             1,
+        group_field:       'name',
+        aggregation_field: 'value',
+        if_field_missing:  -> (node) { [] },
+        ancestry_in_keys:  false, # if false, with_root is ignored
+        with_root:         false
       }
       options = default_options.merge(options)
 
       nodes_of_level(options[:level]).each_with_object({}) do |node, hash|
+        key =
+          if options[:ancestry_in_keys]
+            nodes_for_key = node.with_ancestry({ include_root: options[:with_root] })
+            nodes_for_key.map { |n| get_or_id(n, options[:group_field]) }
+          else
+            get_or_id(node, options[:group_field])
+          end
 
-        key_nodes = if options[:include_ancestry_in_keys]
-                      node.with_ancestry({ include_root: options[:with_root] })
-                    else
-                      node
-                    end
-
-        key = key_nodes.map { |kn| kn.get(options[:group_field]) { |n| n.object_id } }
         value = node.own_and_descendants(options[:aggregation_field], &options[:if_field_missing])
 
         hash[key] = value
       end
     end
 
+    private
+
+    def get_or_id(node, field)
+      node.get(field) { |n| n.object_id }
+    end
+
   end
-end
+end

data/lib/forester/tree_node_ext/mutators.rb

@@ -1,13 +1,20 @@
 module Forester
   module Mutators
 
-    def add_field!(name, definition)
-      value = if definition.respond_to? :call then definition.call(self) else definition end
-      put!(name, value)
-    end
+    def add_field!(name, definition, options = {})
+      default_options = {
+        subtree: true
+      }
+      options = default_options.merge(options)
 
-    def add_field_to_subtree!(name, definition)
-      each_node { |node| node.add_field!(name, definition) }
+      if options[:subtree]
+        each_node do |node|
+          node.add_field!(name, definition, options.merge({ subtree: false }))
+        end
+      else
+        value = definition.respond_to?(:call) ? definition.call(self) : definition
+        put!(name, value)
+      end
     end
 
     def remove_levels_past!(last_level_to_keep)
@@ -16,4 +23,4 @@ module Forester
     end
 
   end
-end
+end

data/lib/forester/tree_node_ext/views.rb

@@ -1,9 +1,11 @@
 module Forester
   module Views
 
-    def as_nested_hash(options = {})
+    def as_root_hash(options = {})
       default_options = {
         fields_to_include: fields, # all of them
+        max_level:         :last,
+        children_key:      :children,
         stringify_keys:    false,
         symbolize_keys:    false
       }
@@ -11,15 +13,22 @@ module Forester
 
       hash = content.to_hash(options)
 
-      children_key = :children
+      children_key = options[:children_key]
       children_key = children_key.to_s if options[:stringify_keys]
 
-      hash.merge(
-        {
-          children_key => children.map { |node| node.as_nested_hash(options) }
-        }
-      )
+      max_level = options[:max_level]
+      max_level = -1 if max_level == :last
+
+      next_children =
+        if max_level == 0
+          []
+        else
+          next_options = options.merge({ max_level: max_level - 1 })
+          children.map { |node| node.as_root_hash(next_options) }
+        end
+
+      hash.merge({ children_key => next_children })
     end
 
   end
-end
+end

data/lib/forester/version.rb

@@ -1,7 +1,7 @@
 module Forester
   class Version
-    MAJOR = 3
-    MINOR = 2
+    MAJOR = 4
+    MINOR = 0
     PATCH = 0
     PRE = nil
 

data/test/simple_tree_helper.rb

@@ -0,0 +1,5 @@
+module SimpleTreeHelper
+  PATH_TO_TREES       = "#{File.dirname(__FILE__)}/trees"
+  PATH_TO_SIMPLE_TREE = "#{PATH_TO_TREES}/simple_tree.yml"
+  @@tree = Forester::TreeFactory.from_yaml_file(PATH_TO_SIMPLE_TREE)
+end

data/test/test_aggregators.rb

@@ -0,0 +1,94 @@
+require 'minitest/autorun'
+require 'forester'
+
+require_relative './simple_tree_helper'
+
+class TestAggregators < Minitest::Test
+
+  include SimpleTreeHelper
+
+  def test_group_by_sibling_subtrees
+
+    expected = {
+      "First node of level 2"  => ["Already in level 2", "I want to be the very best", "like no one ever was"],
+      "Second node of level 2" => ["I have a sibling to my left", "She wants to catch them all"],
+      "Third node of level 2"  => ["Reached level 3", "It's dark", "A hidden secret lies in the deepest leaves...", "Just kidding.", "Could forester handle trees with hundreds of levels?", "Maybe."]
+    }
+
+    actual = @@tree.group_by_sibling_subtrees(
+      level: 2,
+      aggregation_field: 'strings'
+    )
+
+    assert_equal expected, actual
+  end
+
+  def test_group_by_sibling_subtrees_with_ancestry
+
+    expected = {
+      ["First node of level 1", "First node of level 2"]  => ["Already in level 2", "I want to be the very best", "like no one ever was"],
+      ["First node of level 1", "Second node of level 2"] => ["I have a sibling to my left", "She wants to catch them all"],
+      ["Second node of level 1", "Third node of level 2"] => ["Reached level 3", "It's dark", "A hidden secret lies in the deepest leaves...", "Just kidding.", "Could forester handle trees with hundreds of levels?", "Maybe."]
+    }
+
+    actual = @@tree.group_by_sibling_subtrees(
+      level: 2,
+      aggregation_field: 'strings',
+      ancestry_in_keys: true
+    )
+
+    assert_equal expected, actual
+  end
+
+  def test_nodes_with
+    expected_names = ["A hidden secret lies in the deepest leaves...", "Just kidding.", "Could forester handle trees with hundreds of levels?", "Maybe."]
+
+    found_nodes = @@tree.nodes_with('name', 'Second node of level 3')
+    assert_equal 1, found_nodes.length
+
+    actual_names = found_nodes.flat_map do |node|
+      node.own_and_descendants('strings')
+    end
+
+    assert_equal expected_names, actual_names
+  end
+
+  def test_search
+
+    expected = [7]
+
+    actual_1 = @@tree.search({
+      by_field: 'name',
+      keywords: 'Second node of level 3',
+      then_get: 'value',
+      subtree:  false
+    })
+
+    actual_2 = @@tree.search({
+      by_field: 'name',
+      keywords: ['Second node of level 3', 'Not present name'],
+      then_get: 'value',
+      subtree:  false
+    })
+
+    actual_3 = @@tree.search({
+      by_field: 'strings',
+      keywords: 'A hidden secret lies in the deepest leaves...',
+      then_get: 'value',
+      subtree:  false
+    })
+    assert_equal expected, actual_1
+    assert_equal expected, actual_2
+    assert_equal expected, actual_3
+
+    expected_values = [7, 8, 9]
+    actual_values = @@tree.search({
+      by_field: 'name',
+      keywords: 'Second node of level 3',
+      then_get: 'value',
+      subtree:  true
+    })
+    assert_equal expected_values, actual_values
+  end
+
+end

data/test/test_mutators.rb

@@ -1,29 +1,34 @@
 require 'minitest/autorun'
 require 'forester'
 
+require_relative './simple_tree_helper'
+
 class TestMutators < Minitest::Test
 
-  def test_mutators
+  def setup
+    path_to_trees       = "#{File.dirname(__FILE__)}/trees"
+    path_to_simple_tree = "#{path_to_trees}/simple_tree.yml"
+    @tree = Forester::TreeFactory.from_yaml_file(path_to_simple_tree)
+  end
 
-    path_to_trees = "#{File.dirname(__FILE__)}/trees"
-    tree = Forester::TreeFactory.from_yaml_file("#{path_to_trees}/simple_tree.yml")
+  def test_add_field
 
-    tree.add_field_to_subtree!('number_four', 4)
+    @tree.add_field!('number_four', 4)
 
-    assert_equal 4, tree.get(:number_four)
-    assert_equal 4, tree.get('number_four')
+    assert_equal 4, @tree.get(:number_four)
+    assert_equal 4, @tree.get('number_four')
 
-    tree.add_field_to_subtree!(:number_five, 5)
+    @tree.add_field!(:number_five, 5)
 
-    assert_equal 5, tree.get(:number_five)
-    assert_equal 5, tree.get('number_five')
+    assert_equal 5, @tree.get(:number_five)
+    assert_equal 5, @tree.get('number_five')
 
     number_one = 1
 
-    tree.add_field_to_subtree!(:number_six, -> (node) { node.get(:number_five) + number_one })
+    @tree.add_field!(:number_six, -> (node) { node.get(:number_five) + number_one })
 
-    assert_equal 6, tree.get(:number_six)
+    assert_equal 6, @tree.get(:number_six)
 
   end
 
-end
+end

data/test/test_tree_factory.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'forester'
+
+require_relative './simple_tree_helper'
+
+class TestTreeFactory < Minitest::Test
+
+  include SimpleTreeHelper
+
+  def test_from_root_hash
+    hash = YAML.load_file(PATH_TO_SIMPLE_TREE)
+
+    whole_trees = [:last, 29, 4].map { |ml| new_with_max_level(hash, ml) }
+
+    assert(whole_trees.product(whole_trees).all? { |t1, t2| t1.same_as?(t2) })
+
+    pruned_trees = (0..2).map { |ml| new_with_max_level(hash, ml) }
+
+    pruned_trees.each_with_index do |t, i|
+      assert_equal(i, t.max_level)
+
+      pruned = whole_trees[i].remove_levels_past!(i)
+      assert(t.same_as?(pruned))
+    end
+  end
+
+  protected
+
+  def new_with_max_level(hash, max_level)
+    Forester::TreeFactory.from_root_hash(hash['root'], { max_level: max_level })
+  end
+
+end

data/test/test_tree_node.rb

@@ -0,0 +1,34 @@
+require 'minitest/autorun'
+require 'forester'
+
+require_relative './simple_tree_helper'
+
+class TestTreeNode < Minitest::Test
+
+  include SimpleTreeHelper
+
+  def test_size
+    assert_equal 10, @@tree.size
+  end
+
+  def test_values
+    expected = (0..9).reduce(:+)
+    actual   = @@tree.reduce(0) { |acum, node| acum + node.get('value') }
+
+    assert_equal expected, actual
+  end
+
+  def test_levels
+    expected  = [
+                  ["root"],
+                  ["First node of level 1", "Second node of level 1"],
+                  ["First node of level 2", "Second node of level 2", "Third node of level 2"],
+                  ["First node of level 3", "Second node of level 3"],
+                  ["First node of level 4", "Second node of level 4"]
+                ]
+    actual    = @@tree.each_level.map { |l| l.map { |n| n.get('name') } }.to_a
+
+    assert_equal expected, actual
+  end
+
+end

data/test/test_views.rb

@@ -1,18 +1,20 @@
 require 'minitest/autorun'
 require 'forester'
 
-class TestViews < Minitest::Test
+require_relative './simple_tree_helper'
 
-  def test_views
+class TestViews < Minitest::Test
 
-    path_to_trees = "#{File.dirname(__FILE__)}/trees"
-    tree = Forester::TreeFactory.from_yaml_file("#{path_to_trees}/simple_tree.yml")
+  include SimpleTreeHelper
 
-    hash = (YAML.load(File.read("#{path_to_trees}/simple_tree.yml")))
+  def test_as_root_hash
+    hash = (YAML.load(File.read(PATH_TO_SIMPLE_TREE)))
     add_empty_children_keys(hash['root'])
 
-    assert_equal hash['root'], tree.as_nested_hash({ stringify_keys: true })
+    expected = hash['root']
+    actual   = @@tree.as_root_hash({ stringify_keys: true })
 
+    assert_equal expected, actual
   end
 
   private
@@ -22,4 +24,4 @@ class TestViews < Minitest::Test
     hash['children'].each { |child| add_empty_children_keys(child) }
   end
 
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forester
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Eugenio Bruno
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-22 00:00:00.000000000 Z
+date: 2016-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubytree
@@ -89,8 +89,11 @@ files:
 - lib/forester/tree_node_ext/mutators.rb
 - lib/forester/tree_node_ext/views.rb
 - lib/forester/version.rb
+- test/simple_tree_helper.rb
+- test/test_aggregators.rb
 - test/test_mutators.rb
-- test/test_treenode.rb
+- test/test_tree_factory.rb
+- test/test_tree_node.rb
 - test/test_views.rb
 - test/trees/simple_tree.yml
 homepage: http://rubygems.org/gems/forester
@@ -118,7 +121,10 @@ signing_key:
 specification_version: 4
 summary: A gem to represent and interact with tree data structures
 test_files:
+- test/simple_tree_helper.rb
+- test/test_aggregators.rb
 - test/test_mutators.rb
-- test/test_treenode.rb
+- test/test_tree_factory.rb
+- test/test_tree_node.rb
 - test/test_views.rb
 - test/trees/simple_tree.yml

data/test/test_treenode.rb

@@ -1,84 +0,0 @@
-require 'minitest/autorun'
-require 'forester'
-
-class TestTreeNode < Minitest::Test
-
-  def test_tree_node
-
-    path_to_trees = "#{File.dirname(__FILE__)}/trees"
-    tree = Forester::TreeFactory.from_yaml_file("#{path_to_trees}/simple_tree.yml")
-
-    assert_equal 10, tree.size
-
-    assert_equal (0..9).reduce(:+), tree.reduce(0) { |acum, node| acum + node.get('value') }
-
-    expected_levels = [
-                        ["root"],
-                        ["First node of level 1", "Second node of level 1"],
-                        ["First node of level 2", "Second node of level 2", "Third node of level 2"],
-                        ["First node of level 3", "Second node of level 3"],
-                        ["First node of level 4", "Second node of level 4"]
-                      ]
-
-    assert_equal expected_levels, tree.each_level.map { |level| level.map { |n| n.get('name') } }.to_a
-
-    expected = {
-      ["First node of level 1", "First node of level 2"]  => ["Already in level 2", "I want to be the very best", "like no one ever was"],
-      ["First node of level 1", "Second node of level 2"] => ["I have a sibling to my left", "She wants to catch them all"],
-      ["Second node of level 1", "Third node of level 2"] => ["Reached level 3", "It's dark", "A hidden secret lies in the deepest leaves...", "Just kidding.", "Could forester handle trees with hundreds of levels?", "Maybe."]}
-
-    aggregation_result = tree.values_by_subtree_of_level(level: 2, aggregation_field: 'strings', include_ancestry_in_keys: true)
-
-    assert_equal expected, aggregation_result
-
-
-    expected_value = [7]
-    actual_value = tree.search({
-      by_field:   'name',
-      keywords:   'Second node of level 3',
-      then_get:   'value',
-      of_subtree: false,
-    })
-    assert_equal expected_value, actual_value
-
-    expected_value = [7]
-    actual_value = tree.search({
-      by_field:   'name',
-      keywords:   ['Second node of level 3', 'Not present name'],
-      then_get:   'value',
-      of_subtree: false,
-    })
-    assert_equal expected_value, actual_value
-
-    expected_values = [7, 8, 9]
-    actual_values = tree.search({
-      by_field:   'name',
-      keywords:   'Second node of level 3',
-      then_get:   'value',
-      of_subtree: true,
-    })
-    assert_equal expected_values, actual_values
-
-    expected_value = [7]
-    actual_value = tree.search({
-      by_field:   'strings',
-      keywords:   'A hidden secret lies in the deepest leaves...',
-      then_get:   'value',
-      of_subtree: false
-    })
-    assert_equal expected_value, actual_value
-
-
-    expected_names = ["A hidden secret lies in the deepest leaves...", "Just kidding.", "Could forester handle trees with hundreds of levels?", "Maybe."]
-
-    found_nodes = tree.nodes_with('name', 'Second node of level 3')
-    assert_equal 1, found_nodes.length
-
-    actual_names = found_nodes.flat_map do |node|
-      node.own_and_descendants('strings')
-    end
-
-    assert_equal expected_names, actual_names
-  end
-
-end