forester 4.3.0 → 5.0.0

data/lib/forester/tree_node_ext/views.rb

@@ -1,34 +0,0 @@
-module Forester
-  module Views
-
-    def as_root_hash(options = {})
-      default_options = {
-        fields_to_include: :all,
-        max_level:         :last,
-        children_key:      :children,
-        stringify_keys:    false,
-        symbolize_keys:    false
-      }
-      options = default_options.merge(options)
-
-      hash = content.to_hash(options)
-
-      children_key = options[:children_key]
-      children_key = children_key.to_s if options[:stringify_keys]
-
-      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

data/test/minitest_helper.rb

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

@@ -1,48 +0,0 @@
-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,105 +0,0 @@
-require 'minitest_helper'
-
-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."
-                                  ]
-    }
-
-    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,97 +0,0 @@
-require 'minitest_helper'
-
-class TestMutators < Forester::Test
-
-  def test_add_field
-    tree.add_field!('number_four', 4)
-
-    assert_equal 4, tree.get(:number_four)
-    assert_equal 4, tree.get('number_four')
-
-    tree.add_field!(:number_five, 5)
-
-    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)
-  end
-
-  def test_delete_values
-    node_1, node_2, node_3 = nodes_with_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'])
-    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'])
-    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'])
-    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'])
-    assert_equal ['First tag'], node_1.get(:tags)
-    assert_equal [],            node_2.get(:tags)
-    assert_equal [],            node_3.get(: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
-
-  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({
-        single_node: true,
-        by_field: :value,
-        keywords: n
-      }).first
-    end
-  end
-
-end

data/test/test_tree_factory.rb

@@ -1,30 +0,0 @@
-require 'minitest_helper'
-
-class TestTreeFactory < Forester::Test
-
-  def test_from_root_hash
-    hash = YAML.load_file(PATH_TO_SIMPLE_TREE)
-
-    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| from_root_hash(hash, max_level: 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
-
-  private
-
-  def from_root_hash(hash, options = {})
-    Forester::TreeFactory.from_root_hash(hash['root'], options)
-  end
-
-end

data/test/test_tree_node.rb

@@ -1,44 +0,0 @@
-require 'minitest_helper'
-
-class TestTreeNode < Forester::Test
-
-  def test_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') }
-
-    assert_equal expected, actual
-
-    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_raises(ArgumentError) { tree.get('whatever') }
-  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_validators.rb

@@ -1,240 +0,0 @@
-require 'minitest_helper'
-
-class TestValidators < Forester::Test
-
-  def test_validate_uniqueness_of_field_uniques
-    expected = {
-      is_valid: true,
-      repeated: {},
-      failures: {}
-    }
-
-    ['name', :name, 'special', 'ghost'].each do |field|
-      actual = tree.validate_uniqueness_of_field(field)
-      assert_equal expected, actual
-    end
-
-  end
-
-  def test_validate_uniqueness_of_field_color
-    expected = {
-      is_valid: false,
-      repeated: {
-        :color => ['Green', 'Yellow']
-        },
-      failures: {
-        :color => {
-          'Green'  => ['First node of level 1', 'Second node of level 1'],
-          'Yellow' => ['First node of level 4', 'Second node of level 4']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_field(:color)
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_field_color_first_failure_only
-    expected = {
-      is_valid: false,
-      repeated: {
-        :color => ['Green']
-        },
-      failures: {
-        :color => {
-          'Green'  => ['First node of level 1', 'Second node of level 1']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_field(:color, {
-      first_failure_only: true
-    })
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_field_color_among_siblings_of_level_1
-    expected = {
-      is_valid: false,
-      repeated: {
-        :color => ['Green']
-        },
-      failures: {
-        :color => {
-          'Green' => ['First node of level 1', 'Second node of level 1']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_field(:color, {
-      among_siblings_of_level: 1
-    })
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_field_color_among_siblings_of_level_2
-    expected = {
-      is_valid: true,
-      repeated: {},
-      failures: {}
-    }
-
-    actual = tree.validate_uniqueness_of_field(:color, {
-      among_siblings_of_level: 2
-    })
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_field_color_within_subtrees_of_level_1
-    expected = {
-      is_valid: false,
-      repeated: {
-        :color => ['Yellow']
-        },
-      failures: {
-        :color => {
-          'Yellow' => ['First node of level 4', 'Second node of level 4']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_field(:color, {
-      within_subtrees_of_level: 1,
-    })
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_field_color_within_subtrees_of_level_3
-    expected = {
-      is_valid: false,
-      repeated: {
-        :color => ['Yellow']
-        },
-      failures: {
-        :color => {
-          'Yellow' => ['First node of level 4', 'Second node of level 4']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_field(:color, {
-      within_subtrees_of_level: 3,
-    })
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_field_color_within_subtrees_of_level_4
-    expected = {
-      is_valid: true,
-      repeated: {},
-      failures: {}
-    }
-
-    actual = tree.validate_uniqueness_of_field(:color, {
-      within_subtrees_of_level: 4,
-    })
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_fields_name_color
-    expected = {
-      is_valid: false,
-      repeated: {
-        'color' => ['Green', 'Yellow']
-        },
-      failures: {
-        'color' => {
-          'Green'  => ['First node of level 1', 'Second node of level 1'],
-          'Yellow' => ['First node of level 4', 'Second node of level 4']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_fields(['name', 'color'])
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_combination_of_fields_name_color
-    expected = {
-      is_valid: true,
-      repeated: {},
-      failures: {}
-    }
-
-    actual = tree.validate_uniqueness_of_fields(['name', 'color'], {
-      combination: true
-    })
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_fields_color_tone_first_failure_only
-    expected = {
-      is_valid: false,
-      repeated: {
-        'color' => ['Green']
-        },
-      failures: {
-        'color' => {
-          'Green' => ['First node of level 1', 'Second node of level 1']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_fields(['color', 'tone'], {
-      first_failure_only: true
-    })
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_fields_color_tone
-    expected = {
-      is_valid: false,
-      repeated: {
-        'color' => ['Green', 'Yellow'],
-        'tone'  => ['Dark']
-        },
-      failures: {
-        'color' => {
-          'Green'  => ['First node of level 1', 'Second node of level 1'],
-          'Yellow' => ['First node of level 4', 'Second node of level 4']
-        },
-        'tone' => {
-          'Dark' => ['First node of level 1', 'Second node of level 1']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_fields(['color', 'tone'])
-
-    assert_equal expected, actual
-  end
-
-  def test_validate_uniqueness_of_combination_of_fields_color_tone
-    expected = {
-      is_valid: false,
-      repeated: {
-        ['color', 'tone'] => [['Green', 'Dark']]
-        },
-      failures: {
-        ['color', 'tone'] => {
-          ['Green', 'Dark'] => ['First node of level 1', 'Second node of level 1']
-        }
-      }
-    }
-
-    actual = tree.validate_uniqueness_of_fields(['color', 'tone'], {
-      combination: true
-    })
-
-    assert_equal expected, actual
-  end
-
-end