forester 4.2.1 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 074b7d10b4541bc5b2e70d3013990b687ad32e7c
-  data.tar.gz: 99fd514939cd284d71b6388f167d7bc5226a2ce0
+  metadata.gz: 10d063cbc60a90d3e5ebe19867e2b47ae74f59fe
+  data.tar.gz: b2fb62970c91d0f75c18f01efb0f7e502da1e05e
 SHA512:
-  metadata.gz: 19320bf3a2d4dbe72f192d0ad370cb0f082206e572371e8013ce036e0f645062025300420ae10e25ab1e368300bf45ced1223dfc973e040f53d759be1b5d025f
-  data.tar.gz: 202fe5a6556f0df1fe6f12b9c547da61d835151ca23e0bbfb5261aa1505828a6a4fe0feb09dfb42341ff7769f1213cbc5e38f602a6980144ebe2c32cda8ddb24
+  metadata.gz: 53099d57189bde522ff5310b9532ba91f9338beec8f2676735ea837a1c0e23977f333ad177e15d6268981bb0ba24dd104d89b1d5e75ec1c660e0288db87a1cd5
+  data.tar.gz: 8a1e31896c0469536e4279e3095d573cb84f048e689f2693e70134dbaa0263720034cf97f4ceac72628e45720a10388dac085e133afb1292ffa3375a005fa648

data/.gitignore

@@ -0,0 +1,35 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3
+  - 2.4
+  - jruby
+before_install:
+  - gem install bundler

data/README.md

@@ -1,5 +1,7 @@
 # Forester
 
+[![Gem Version](https://badge.fury.io/rb/forester.svg)](https://badge.fury.io/rb/forester)
+
 Based on *rubytree*, this gem lets you build trees and run queries against them.
 
 ## FAQ

data/Rakefile

@@ -1,8 +1,17 @@
 require 'rake/testtask'
 
 Rake::TestTask.new do |t|
+  t.libs << 'test'
   t.pattern = "test/**/test_*.rb"
 end
 
 desc "Run tests"
-task :default => :test
+task default: :test
+
+desc 'Start a REPL session'
+task :console do
+  require 'forester'
+  require 'pry'
+  ARGV.clear
+  Pry.start
+end

data/forester.gemspec

@@ -7,24 +7,24 @@ Gem::Specification.new do |s|
   s.name        = 'forester'
   s.version     = Forester::Version
   s.date        = '2017-02-26'
-  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"]
+  s.summary     = "A trees library"
+  s.description = "Forester is a collection of utilities to represent and interact with tree data structures."
+  s.authors     = "Eugenio Bruno"
   s.email       = 'eugeniobruno@gmail.com'
   s.homepage    = 'https://github.com/eugeniobruno/forester'
   s.license     = 'MIT'
 
   s.files         = `git ls-files`.split($/)
-  s.executables   = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ['lib']
 
   s.required_ruby_version = '>= 2.0.0'
 
-  s.add_runtime_dependency 'rubytree', ['0.9.7']
+  s.add_runtime_dependency 'rubytree', '0.9.7'
 
-  s.add_development_dependency 'rake', ['~> 11.2']
-  s.add_development_dependency 'minitest', ['~> 5.9']
-  s.add_development_dependency 'pry-byebug', ['~> 3.4']
+  s.add_development_dependency 'rake', '~> 12.0'
+  s.add_development_dependency 'minitest', '~> 5.10'
+  s.add_development_dependency 'simplecov', '~> 0.14'
+  s.add_development_dependency 'pry-byebug', '~> 3.4'
 
 end

data/lib/forester/node_content/dictionary.rb

@@ -76,7 +76,7 @@ module Forester
         self.class.new(super)
       end
 
-      protected
+      private
 
       def equivs(key)
         [key, key.to_s, key.to_s.to_sym].uniq

data/lib/forester/node_content/factory.rb

@@ -1,25 +1,23 @@
 module Forester
   module NodeContent
-    class Factory
+    module Factory
 
-      class << self
+      extend self
 
-        def from_hash(hash, children_key, indifferent = true)
-          ret = without_key(hash, children_key)
-          ret = Dictionary.new(ret) if indifferent
-          ret
-        end
-
-        def from_array(array)
-          List.new(array)
-        end
+      def from_hash(hash, children_key, indifferent = true)
+        ret = without_key(hash, children_key)
+        ret = Dictionary.new(ret) if indifferent
+        ret
+      end
 
-        private
+      def from_array(array)
+        List.new(array)
+      end
 
-        def without_key(hash, key)
-          hash.reject { |k, _| k.to_s == key.to_s }
-        end
+      private
 
+      def without_key(hash, key)
+        hash.reject { |k, _| k.to_s == key.to_s }
       end
 
     end

data/lib/forester/tree_factory.rb

@@ -1,62 +1,75 @@
 module Forester
-  class TreeFactory
+  module TreeFactory
 
-    class << self
+    extend self
 
-      def from_yaml_file(file, options = {})
-        from_hash_with_root_key(YAML.load_file(file), options)
-      end
+    def node_from_hash(hash, options = {}, &block)
+      # TODO remove the whole node_content folder in next major version
+      # and let the user choose a class for the contents via a custom parser.
+      # That class should have the interface of the one used by the default parser.
+      # The default parser should be the constructor of Hash::Accessible, which
+      # is defined in the gem 'hash_ext'. Add it as a runtime dependency.
+      do_node_from_hash(hash, nil, options, &block)
+    end
 
-      def from_root_hash(hash, options = {})
-        from_hash_with_root_key({ root: hash }, options)
-      end
+    def from_yaml_file(file, options = {})
+      from_hash_with_root_key(YAML.load_file(file), options)
+    end
 
-      def from_hash_with_root_key(hash, options = {})
-        default_options = {
-          max_level:    :last,
-          children_key: :children,
-          root_key:     :root
-        }
-        options = default_options.merge(options)
+    def from_root_hash(hash, options = {})
+      from_hash_with_root_key({ root: hash }, options)
+    end
 
-        dummy_root = TreeNode.new('<TEMP>')
-        real_root  = fetch_indifferently(hash, options[:root_key])
+    def from_hash_with_root_key(hash, options = {})
+      default_options = {
+        max_level:    :last,
+        children_key: :children,
+        root_key:     :root
+      }
+      options = default_options.merge(options)
 
-        max_level = options[:max_level]
-        max_level = -2 if max_level == :last
+      options[:max_level] = -2 if options[:max_level] == :last
 
-        tree = with_children(dummy_root, [real_root], options[:children_key], max_level + 1).first_child
-        tree.detached_subtree_copy
-      end
+      dummy_root = TreeNode.new('<TEMP>')
+      real_root  = fetch_indifferently(hash, options[:root_key])
+
+      tree = with_children(dummy_root, [real_root], options[:children_key], options[:max_level] + 1).first_child
+      tree.detached_subtree_copy
+    end
 
-      protected
+    private
 
-      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 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, levels_remaining)
-        return tree_node if levels_remaining == 0
-        children.each do |child|
-          child_node     = node_from_hash(child, children_key)
-          child_children = fetch_indifferently(child, children_key, [])
+    def with_children(tree_node, children, children_key, levels_remaining)
+      return tree_node if levels_remaining == 0
+      children.each do |child_hash|
+        child_node     = do_node_from_hash(child_hash, children_key)
+        child_children = fetch_indifferently(child_hash, children_key, [])
 
-          tree_node << with_children(child_node, child_children, children_key, levels_remaining - 1)
-        end
-        tree_node
+        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)
+    def do_node_from_hash(hash, children_key, options = {}, &block)
+      content = NodeContent::Factory.from_hash(hash, children_key)
+      node(content, options, &block)
+    end
 
-        name    = options[:uid]
-        content = NodeContent::Factory.from_hash(hash, children_key)
-        TreeNode.new(name, content)
-      end
+    def node(content, options = {})
+      default_options = {
+        uid: SecureRandom.uuid
+      }
+      options = default_options.merge(options)
+
+      name = options[:uid]
+      new_node = TreeNode.new(name, content)
 
+      yield new_node if block_given?
+      new_node
     end
 
   end

data/lib/forester/tree_node.rb

@@ -10,12 +10,46 @@ module Forester
     include Views
 
     alias_method :max_level, :node_height
-    alias_method :each_node, :breadth_each
 
     def nodes_of_level(l)
       l.between?(0, max_level) ? each_level.take(l + 1).last : []
     end
 
+    def each_node(options = {})
+      default_options = {
+        traversal: :breadth_first
+      }
+      options = default_options.merge(options)
+
+      case options[:traversal]
+      when :breadth_first
+        breadth_each
+      when :depth_first
+        each
+      when :postorder
+        postordered_each
+      when :preorder
+        preordered_each
+      else
+        raise ArgumentError, "invalid traversal mode: #{options[:traversal]}"
+      end
+    end
+
+    def each_content(options = {})
+      node_enumerator = each_node(options)
+
+      Enumerator.new do |yielder|
+        stop = false
+        until stop
+          begin
+            yielder << node_enumerator.next.content
+          rescue StopIteration
+            stop = true
+          end
+        end
+      end
+    end
+
     def each_level
       Enumerator.new do |yielder|
         level = [self]
@@ -29,11 +63,12 @@ module Forester
     def get(field, options = {}, &if_missing)
       default_options = {
         default: :raise,
-        subtree: false
+        subtree: false, # if false, traversal is ignored
+        traversal: :depth_first
       }
       options = default_options.merge(options)
 
-      return own_and_descendants(field, &if_missing) if options[:subtree]
+      return own_and_descendants(field, { traversal: options[:traversal] }, &if_missing) if options[:subtree]
 
       if has?(field)
         content.get(field)
@@ -42,12 +77,12 @@ module Forester
       elsif options[:default] != :raise
         options[:default]
       else
-        raise ArgumentError.new("the node \"#{name}\" does not have \"#{field}\"")
+        raise ArgumentError, "the node \"#{best_name}\" does not have \"#{field}\""
       end
     end
 
-    def contents
-      each_node.map(&:content)
+    def contents(options = {})
+      each_node(options).map(&:content)
     end
 
     def same_as?(other)
@@ -61,7 +96,11 @@ module Forester
       true
     end
 
-    protected
+    private
+
+    def best_name
+      get(:name, default: name)
+    end
 
     def as_array(object)
       [object].flatten(1)

data/lib/forester/tree_node_ext/aggregators.rb

@@ -1,10 +1,17 @@
 module Forester
   module Aggregators
 
-    def own_and_descendants(field, &if_missing)
+    def own_and_descendants(field, options = {}, &if_missing)
+      default_options = {
+        traversal: :depth_first
+      }
+      options = default_options.merge(options)
+
       if_missing = -> (node) { [] } unless block_given?
 
-      flat_map { |node| as_array(node.get(field, &if_missing)) }
+      each_node(traversal: options[:traversal]).flat_map do |node|
+        as_array(node.get(field, &if_missing))
+      end
     end
 
     def nodes_with(field, values, options = {})
@@ -49,6 +56,9 @@ module Forester
       found_nodes = nodes_with(options[:by_field], options[:keywords], single: options[:single_node] )
 
       return found_nodes if options[:then_get] == :nodes
+      # TODO this method should never return [nil]. This happens when single_node
+      # is true and no matches are found. Moreover, if then_get is not :nodes,
+      # it should not raise. Both cases should return [].
 
       found_nodes.flat_map do |node|
         node.get(options[:then_get], subtree: options[:subtree])

data/lib/forester/tree_node_ext/mutators.rb

@@ -1,8 +1,24 @@
 module Forester
   module Mutators
 
+    def change_parent_to!(new_parent_node, options = {})
+      default_options = {
+        subtree: true
+      }
+      options = default_options.merge(options)
+
+      children.each { |child| parent.add(child) } unless options[:subtree]
+
+      new_parent_node.add(self) # always as its last child
+    end
+
+    def add_child_content!(content, options = {}, &block)
+      new_node = TreeFactory.node_from_hash(content, options, &block)
+      add(new_node)
+    end
+
     def add_field!(name, definition, options = {})
-      add_fields!([{ name: name, definition: definition }], options)
+      add_fields!([name: name, definition: definition], options)
     end
 
     def add_fields!(fields, options = {})

data/lib/forester/tree_node_ext/views.rb

@@ -27,7 +27,7 @@ module Forester
           children.map { |node| node.as_root_hash(next_options) }
         end
 
-      hash.merge({ children_key => next_children })
+      hash.merge(children_key => next_children)
     end
 
   end

data/lib/forester/version.rb

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

data/test/minitest_helper.rb

@@ -0,0 +1,41 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'test/'
+end
+
+require 'minitest/autorun'
+
+require 'pry-byebug'
+
+require 'forester'
+
+class Forester::Test < Minitest::Test
+
+  private
+
+  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)
+
+  BINARY_TREE = Forester::TreeFactory.node_from_hash(name: :top) do |parent|
+    parent.add_child_content!(name: :left) do |left|
+      left.add_child_content!(name: :left_left) do |left_left|
+        left_left.add_child_content!(name: :left_left_left)
+      end
+      left.add_child_content!(name: :left_right)
+    end
+    parent.add_child_content!(name: :right) do |right|
+      right.add_child_content!(name: :right_left)
+      right.add_child_content!(name: :right_right)
+    end
+  end
+
+  def tree
+    TREE
+  end
+
+  def binary_tree
+    BINARY_TREE
+  end
+
+end

data/test/test_ad_hoc_tree.rb

@@ -0,0 +1,48 @@
+require 'minitest_helper'
+
+class TestAdHocTree < Forester::Test
+
+  def test_content
+    assert_equal({ number: 1 }, Forester::TreeFactory.node_from_hash(number: 1).content)
+  end
+
+  def test_each_node_type
+    assert_instance_of Enumerator, binary_tree.each_node
+  end
+
+  def test_each_content_type
+    assert_instance_of Enumerator, binary_tree.each_content
+  end
+
+  def test_each_content_depth_first
+    expected = %i(top left left_left left_left_left left_right right right_left right_right)
+    assert_equal expected, binary_tree.get(:name, subtree: true, traversal: :depth_first)
+    assert_equal expected, binary_tree.each_node(traversal: :depth_first).map { |n| n.get(:name) }
+    assert_equal expected, binary_tree.each_content(traversal: :depth_first).map { |c| c[:name] }
+  end
+
+  def test_each_content_breadth_first
+    expected = %i(top left right left_left left_right right_left right_right left_left_left)
+
+    assert_equal expected, binary_tree.get(:name, subtree: true, traversal: :breadth_first)
+    assert_equal expected, binary_tree.each_node(traversal: :breadth_first).map { |n| n.get(:name) }
+    assert_equal expected, binary_tree.each_node.map { |n| n.get(:name) }
+    assert_equal expected, binary_tree.each_content(traversal: :breadth_first).map { |c| c[:name] }
+    assert_equal expected, binary_tree.each_content.map { |c| c[:name] }
+  end
+
+  def test_each_content_postorder
+    expected = %i(left_left_left left_left left_right left right_left right_right right top)
+    assert_equal expected, binary_tree.get(:name, subtree: true, traversal: :postorder)
+    assert_equal expected, binary_tree.each_node(traversal: :postorder).map { |n| n.get(:name) }
+    assert_equal expected, binary_tree.each_content(traversal: :postorder).map { |c| c[:name] }
+  end
+
+  def test_each_content_preorder
+    expected = %i(top left left_left left_left_left left_right right right_left right_right)
+    assert_equal expected, binary_tree.get(:name, subtree: true, traversal: :preorder)
+    assert_equal expected, binary_tree.each_node(traversal: :preorder).map { |n| n.get(:name) }
+    assert_equal expected, binary_tree.each_content(traversal: :preorder).map { |c| c[:name] }
+  end
+
+end

data/test/test_aggregators.rb

@@ -1,21 +1,29 @@
-require 'minitest/autorun'
-require 'forester'
+require 'minitest_helper'
 
-require_relative './simple_tree_helper'
-
-class TestAggregators < Minitest::Test
-
-  include SimpleTreeHelper
+class TestAggregators < Forester::Test
 
   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."]
+      "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(
+    actual = tree.group_by_sibling_subtrees(
       level: 2,
       aggregation_field: 'strings'
     )
@@ -24,14 +32,13 @@ class TestAggregators < Minitest::Test
   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(
+    actual = tree.group_by_sibling_subtrees(
       level: 2,
       aggregation_field: 'strings',
       ancestry_in_keys: true
@@ -41,9 +48,14 @@ class TestAggregators < Minitest::Test
   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')
+    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|
@@ -54,24 +66,23 @@ class TestAggregators < Minitest::Test
   end
 
   def test_search
-
     expected = [7]
 
-    actual_1 = @@tree.search({
+    actual_1 = tree.search({
       by_field: 'name',
       keywords: 'Second node of level 3',
       then_get: 'value',
       subtree:  false
     })
 
-    actual_2 = @@tree.search({
+    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({
+    actual_3 = tree.search({
       by_field: 'strings',
       keywords: 'A hidden secret lies in the deepest leaves...',
       then_get: 'value',
@@ -82,7 +93,7 @@ class TestAggregators < Minitest::Test
     assert_equal expected, actual_3
 
     expected_values = [7, 8, 9]
-    actual_values = @@tree.search({
+    actual_values = tree.search({
       by_field: 'name',
       keywords: 'Second node of level 3',
       then_get: 'value',

data/test/test_mutators.rb

@@ -1,89 +1,96 @@
-require 'minitest/autorun'
-require 'forester'
+require 'minitest_helper'
 
-require_relative './simple_tree_helper'
-
-class TestMutators < Minitest::Test
-
-  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
+class TestMutators < Forester::Test
 
   def test_add_field
+    tree.add_field!('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!(: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!(:number_six, -> (node) { node.get(:number_five) + number_one })
-
-    assert_equal 6, @tree.get(:number_six)
+    tree.add_field!(:number_six, -> (node) { node.get(:number_five) + number_one })
 
+    assert_equal 6, tree.get(:number_six)
   end
 
   def test_delete_values
-
     node_1, node_2, node_3 = nodes_with_tags
 
-    @tree.delete_values!(:tags, [])
+    tree.delete_values!(:tags, [])
     assert_equal ['First tag', 'Second tag', 'Third tag'], node_1.get(:tags)
     assert_equal ['Second tag', 'Third tag'],              node_2.get(:tags)
     assert_equal ['Third tag'],                            node_3.get(:tags)
 
-    @tree.delete_values!(:tags, ['First tag'])
+    tree.delete_values!(:tags, ['First tag'])
     assert_equal ['Second tag', 'Third tag'], node_1.get(:tags)
     assert_equal ['Second tag', 'Third tag'], node_2.get(:tags)
     assert_equal ['Third tag'],               node_3.get(:tags)
 
-    @tree.delete_values!(:tags, ['First tag', 'Second tag', 'Third tag'])
+    tree.delete_values!(:tags, ['First tag', 'Second tag', 'Third tag'])
     assert_equal [], node_1.get(:tags)
     assert_equal [], node_2.get(:tags)
     assert_equal [], node_3.get(:tags)
-
   end
 
   def test_percolate_values
-
     node_1, node_2, node_3 = nodes_with_tags
 
-    @tree.percolate_values!(:tags, ['First tag', 'Second tag', 'Third tag'])
+    tree.percolate_values!(:tags, ['First tag', 'Second tag', 'Third tag'])
     assert_equal ['First tag', 'Second tag', 'Third tag'], node_1.get(:tags)
     assert_equal ['Second tag', 'Third tag'],              node_2.get(:tags)
     assert_equal ['Third tag'],                            node_3.get(:tags)
 
-    @tree.percolate_values!(:tags, ['First tag'])
+    tree.percolate_values!(:tags, ['First tag'])
     assert_equal ['First tag'], node_1.get(:tags)
     assert_equal [],            node_2.get(:tags)
     assert_equal [],            node_3.get(:tags)
 
-    @tree.percolate_values!(:tags, [])
+    tree.percolate_values!(:tags, [])
     assert_equal [], node_1.get(:tags)
     assert_equal [], node_2.get(:tags)
     assert_equal [], node_3.get(:tags)
+  end
+
+  def test_change_parent_to
+    node_to_move = binary_tree.search(single_node: true, by_field: :name, keywords: [:left_left]).first
+    old_parent   = binary_tree.search(single_node: true, by_field: :name, keywords: [:left]).first
+    new_parent   = binary_tree.search(single_node: true, by_field: :name, keywords: [:right]).first
 
+    node_to_move.change_parent_to!(new_parent)
+
+    expected = %i(top left left_right right right_left right_right left_left left_left_left)
+    assert_equal expected, binary_tree.get(:name, subtree: true, traversal: :depth_first)
+
+    node_to_move.change_parent_to!(old_parent, subtree: false)
+
+    expected = %i(top left left_right left_left right right_left right_right left_left_left)
+    assert_equal expected, binary_tree.get(:name, subtree: true, traversal: :depth_first)
   end
 
-  protected
+  private
+
+  def tree
+    @mutable_tree ||= super.detached_subtree_copy
+  end
+
+  def binary_tree
+    @mutable_binary_tree ||= super.detached_subtree_copy
+  end
 
   def nodes_with_tags
     [1, 6, 9].map do |n|
-
-      @tree.search({
+      tree.search({
         single_node: true,
         by_field: :value,
         keywords: n
       }).first
-
     end
   end
 

data/test/test_tree_factory.rb

@@ -1,20 +1,17 @@
-require 'minitest/autorun'
-require 'forester'
+require 'minitest_helper'
 
-require_relative './simple_tree_helper'
-
-class TestTreeFactory < Minitest::Test
-
-  include SimpleTreeHelper
+class TestTreeFactory < Forester::Test
 
   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) }
+    whole_tree = from_root_hash(hash)
+
+    whole_trees = [whole_tree] + [29, 4].map { |ml| from_root_hash(hash, max_level: 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 = (0..2).map { |ml| from_root_hash(hash, max_level: ml) }
 
     pruned_trees.each_with_index do |t, i|
       assert_equal(i, t.max_level)
@@ -24,10 +21,10 @@ class TestTreeFactory < Minitest::Test
     end
   end
 
-  protected
+  private
 
-  def new_with_max_level(hash, max_level)
-    Forester::TreeFactory.from_root_hash(hash['root'], max_level: max_level)
+  def from_root_hash(hash, options = {})
+    Forester::TreeFactory.from_root_hash(hash['root'], options)
   end
 
 end

data/test/test_tree_node.rb

@@ -1,34 +1,31 @@
-require 'minitest/autorun'
-require 'forester'
+require 'minitest_helper'
 
-require_relative './simple_tree_helper'
-
-class TestTreeNode < Minitest::Test
-
-  include SimpleTreeHelper
+class TestTreeNode < Forester::Test
 
   def test_size
-    assert_equal 10, @@tree.size
+    assert_equal 10, tree.size
   end
 
   def test_values
     values = (0..9).to_a
 
     expected = values.reduce(:+)
-    actual   = @@tree.reduce(0) { |acum, node| acum + node.get('value') }
+    actual   = tree.reduce(0) { |acum, node| acum + node.get('value') }
 
     assert_equal expected, actual
 
-    assert_equal values, @@tree.get('value', subtree: true)
+    assert_equal values, tree.get('value', subtree: true)
   end
 
   def test_missing_values
-    assert_equal 0,    @@tree.get('value')
-    assert_equal 'no', @@tree.get('whatever', default: 'no')
-    assert_equal 'no', @@tree.get('whatever', default: 'missing') { 'no' }
-    assert_equal 'no', @@tree.get('whatever') { 'no' }
-    assert_equal 'no', @@tree.get('whatever') { |n| 'no' }
-    assert_equal 1,    @@tree.get('whatever') { |n| n.get('value') + 1 }
+    assert_equal 0,    tree.get('value')
+    assert_equal 'no', tree.get('whatever', default: 'no')
+    assert_equal 'no', tree.get('whatever', default: 'missing') { 'no' }
+    assert_equal 'no', tree.get('whatever') { 'no' }
+    assert_equal 'no', tree.get('whatever') { |n| 'no' }
+    assert_equal 1,    tree.get('whatever') { |n| n.get('value') + 1 }
+
+    assert_raises(ArgumentError) { tree.get('whatever') }
   end
 
   def test_levels
@@ -39,7 +36,7 @@ class TestTreeNode < Minitest::Test
                   ["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
+    actual    = tree.each_level.map { |l| l.map { |n| n.get('name') } }.to_a
 
     assert_equal expected, actual
   end

data/test/test_validators.rb

@@ -1,11 +1,6 @@
-require 'minitest/autorun'
-require 'forester'
+require 'minitest_helper'
 
-require_relative './simple_tree_helper'
-
-class TestValidators < Minitest::Test
-
-  include SimpleTreeHelper
+class TestValidators < Forester::Test
 
   def test_validate_uniqueness_of_field_uniques
     expected = {
@@ -15,7 +10,7 @@ class TestValidators < Minitest::Test
     }
 
     ['name', :name, 'special', 'ghost'].each do |field|
-      actual = @@tree.validate_uniqueness_of_field(field)
+      actual = tree.validate_uniqueness_of_field(field)
       assert_equal expected, actual
     end
 
@@ -35,7 +30,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_field(:color)
+    actual = tree.validate_uniqueness_of_field(:color)
     assert_equal expected, actual
   end
 
@@ -52,7 +47,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_field(:color, {
+    actual = tree.validate_uniqueness_of_field(:color, {
       first_failure_only: true
     })
     assert_equal expected, actual
@@ -71,7 +66,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_field(:color, {
+    actual = tree.validate_uniqueness_of_field(:color, {
       among_siblings_of_level: 1
     })
 
@@ -85,7 +80,7 @@ class TestValidators < Minitest::Test
       failures: {}
     }
 
-    actual = @@tree.validate_uniqueness_of_field(:color, {
+    actual = tree.validate_uniqueness_of_field(:color, {
       among_siblings_of_level: 2
     })
 
@@ -105,7 +100,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_field(:color, {
+    actual = tree.validate_uniqueness_of_field(:color, {
       within_subtrees_of_level: 1,
     })
 
@@ -125,7 +120,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_field(:color, {
+    actual = tree.validate_uniqueness_of_field(:color, {
       within_subtrees_of_level: 3,
     })
 
@@ -139,7 +134,7 @@ class TestValidators < Minitest::Test
       failures: {}
     }
 
-    actual = @@tree.validate_uniqueness_of_field(:color, {
+    actual = tree.validate_uniqueness_of_field(:color, {
       within_subtrees_of_level: 4,
     })
 
@@ -160,7 +155,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_fields(['name', 'color'])
+    actual = tree.validate_uniqueness_of_fields(['name', 'color'])
 
     assert_equal expected, actual
   end
@@ -172,7 +167,7 @@ class TestValidators < Minitest::Test
       failures: {}
     }
 
-    actual = @@tree.validate_uniqueness_of_fields(['name', 'color'], {
+    actual = tree.validate_uniqueness_of_fields(['name', 'color'], {
       combination: true
     })
 
@@ -192,7 +187,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_fields(['color', 'tone'], {
+    actual = tree.validate_uniqueness_of_fields(['color', 'tone'], {
       first_failure_only: true
     })
 
@@ -217,7 +212,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_fields(['color', 'tone'])
+    actual = tree.validate_uniqueness_of_fields(['color', 'tone'])
 
     assert_equal expected, actual
   end
@@ -235,7 +230,7 @@ class TestValidators < Minitest::Test
       }
     }
 
-    actual = @@tree.validate_uniqueness_of_fields(['color', 'tone'], {
+    actual = tree.validate_uniqueness_of_fields(['color', 'tone'], {
       combination: true
     })
 

data/test/test_views.rb

@@ -1,18 +1,13 @@
-require 'minitest/autorun'
-require 'forester'
+require 'minitest_helper'
 
-require_relative './simple_tree_helper'
-
-class TestViews < Minitest::Test
-
-  include SimpleTreeHelper
+class TestViews < Forester::Test
 
   def test_as_root_hash
-    hash = (YAML.load(File.read(PATH_TO_SIMPLE_TREE)))
+    hash = YAML.load_file(PATH_TO_SIMPLE_TREE)
     add_empty_children_keys(hash['root'])
 
     expected = hash['root']
-    actual   = @@tree.as_root_hash(stringify_keys: true)
+    actual   = tree.as_root_hash(stringify_keys: true)
 
     assert_equal expected, actual
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forester
 version: !ruby/object:Gem::Version
-  version: 4.2.1
+  version: 4.3.0
 platform: ruby
 authors:
 - Eugenio Bruno
@@ -30,28 +30,42 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '11.2'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '11.2'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '5.9'
+        version: '5.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '5.9'
+        version: '5.10'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.14'
 - !ruby/object:Gem::Dependency
   name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
@@ -66,13 +80,15 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.4'
-description: Based on rubytree, this gem lets you build trees and run queries against
-  them.
+description: Forester is a collection of utilities to represent and interact with
+  tree data structures.
 email: eugeniobruno@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
@@ -90,7 +106,8 @@ files:
 - lib/forester/tree_node_ext/validators.rb
 - lib/forester/tree_node_ext/views.rb
 - lib/forester/version.rb
-- test/simple_tree_helper.rb
+- test/minitest_helper.rb
+- test/test_ad_hoc_tree.rb
 - test/test_aggregators.rb
 - test/test_mutators.rb
 - test/test_tree_factory.rb
@@ -121,9 +138,10 @@ rubyforge_project:
 rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: A gem to represent and interact with tree data structures
+summary: A trees library
 test_files:
-- test/simple_tree_helper.rb
+- test/minitest_helper.rb
+- test/test_ad_hoc_tree.rb
 - test/test_aggregators.rb
 - test/test_mutators.rb
 - test/test_tree_factory.rb

data/test/simple_tree_helper.rb

@@ -1,5 +0,0 @@
-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