search_tree 1.1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 919b31f780576cc1906242bb950b6a1ee9e4cfd9c704e46bbf5a1f80509d6ddc
+  data.tar.gz: e585b587411334cc9f27579def854b5c38ad1fc9688af36f88f69eb70b834316
+SHA512:
+  metadata.gz: a085087340e456d665f5dd2b4e98549cf34cd91dd8b37f42774fa5c5aa20e8b5407e4eb4a1f949a47d8ce3936f411594d6dfd78381b4ea5e10abb784a2673d30
+  data.tar.gz: 9d27ee80fcfddfb7168fb0cd413926f287c8cf9a4aedc6ce6ed21dc41f3ad9a70d62a35569764709ddfe951ef48977528b8f0037098f780c032b81629ea68539

data/README.md

@@ -0,0 +1,189 @@
+# Search-tree - Open source search binary tree and bi-dimensional tree.
+
+[![Forks][forks-shield]][forks-url] [![Stars][stars-shield]][stars-url] [![Issues][issues-shield]][issues-url] [![Inline docs][docs-shield]][docs-url] [![Twitter][twitter-shield]][twitter-url]
+
+Search tree is an open-source binary and bi-dimensional tree gem for ruby.
+For more information about why and how it was done visit my [article][article-url] in [Medium][medium-phalado].
+
+<p align="center">
+    <a href="https://github.com/phalado/Search-tree/issues">Report Bug</a>
+    -  <a href="https://github.com/phalado/Search-tree/issues">Request Feature</a>
+</p>
+
+<!-- TABLE OF CONTENTS -->
+## Table of Contents
+
+* [Install and Usage](#install-and-usage)
+* [Available Methods](#avaiable-methods)
+  * [New node](#new-node)
+  * [Search](#search)
+  * [Search node](#search_node)
+  * [Edit node](#edit_node)
+  * [Delete node](#delete-node)
+  * [Print tree](#print-tree)
+  * [Number of nodes](#number-of-nodes)
+  * [Get depth](#get-depth)
+  * [Is balanced](#is-balanced)
+  * [Balance](#balance)
+  * [Get nodes](#get-nodes)
+  * [New balance nodes](#new-balance-nodes)
+  * [New node balanced](#new-node-balanced)
+  * [Load file](#load-file)
+  * [Save file](#save-file)
+* [Author and Contribution](#author-and-contribution)
+* [License](#license)
+* [Future Works](#future-works)
+
+## Install and Usage
+
+Download the [gem file][gem-file] and use the following command to install:
+```bash
+gem install search_tree-[version].gem
+```
+After installing add
+```ruby
+ require 'search_tree'
+ ```
+  in your code and you can use its methods.
+
+## Available Methods
+
+First, you have to create a new tree using the ``BinaryTree`` class, as for example below:
+
+```ruby
+t = BinaryTree.new
+```
+In the ``initialize`` method the **root** variable is defined as *nil*.
+
+### New node
+```ruby
+new_node(node, x, *args)
+```
+This method is used to create a new node in the tree. It receives the **node** where the search begins, **x** as the search parameter and the pointer **args** that will receive all the other arguments added to the node.
+
+### Search
+```ruby
+search(x, node = @root)
+```
+Returns *true* if, starting at the passed **node**, it finds a node with the search parameter **x** and *false* if it finds a *nil*.
+
+### Search node
+```ruby
+search_node(x, node = @root)
+```
+Like the previus one but instead of returning *true* or *false* returns the pointer to the node with search parameter **x** or *nil*.
+
+### Edit node
+```ruby
+edit_node(x, *args)
+```
+Locate the node with search parameter **x** and changer its *arguments* for the ones in **args**, if this node existis.
+
+### Delete node
+```ruby
+delete_node(x)
+```
+Delete the node with the dearch parameter **x**, if exists.
+
+### Print tree
+```ruby
+print_tree(node = @root)
+```
+Print the tree, or sub-tree starting at the passed **node**, in crescent search parameter order.
+
+### Number of nodes
+```ruby
+number_nodes(node = @root)
+```
+Return the number of nodes in the tree, or sub-tree starting at the passed **node**.
+
+### Get depth
+```ruby
+get_depth(node = @root, depth = 1, maxdepth = 0)
+```
+Return the depth of the tree, or sub-tree starting at the passed **node**. The **depth** and **maxdepth** are used as helpers inside the method.
+
+### Is balanced
+```ruby
+is_balanced?
+```
+Return *true* if the number of nodes is smaller than ``2 ^ (depth - 1)`` and bigger than ``2 ^ depth`` and *false* otherwise.
+
+### Balance
+```ruby
+balance
+```
+Balance the tree unless ``is_balanced?`` returns *true*.
+
+### Get nodes
+```ruby
+get_nodes(nodes, node = @root)
+```
+Return the array **nodes** with all the nodes in the crescent search parameter order in the tree or sub-tree starting at the passed **node**. Used to balance the tree.
+
+### New balance nodes
+```ruby
+new_balance_nodes(nodes, newroot = @root)
+```
+Used to create a new node with the array **nodes** received in the ``get_nodes`` method.
+
+### New node balanced
+```ruby
+new_node_balanced(node, x, *args)
+```
+Create a new node and balance the tree.
+
+### Load file
+```ruby
+load_file(file)
+```
+Create a tree with the data inside a file. The search parameter will always be a string.
+
+### Save file
+```ruby
+save_file(file)
+```
+Create a file with the data in the tree.
+
+## Author and Contribution
+
+Add me at [linkedin][linkedin-url], send me an [email][phalado@gmail.com], visit my [twitter][twitter-url], [medium][medium-phalado] and [portfolio][my-portfolio].
+
+Feel free to contribute with pull requests but, for major changes, please open an issue first.
+
+## License
+
+Coming soon
+
+## Future works
+
+Already started a load file and a save file methods.
+
+Have a big ambition to create the bi-dimensional tree. I will do it in the next days.
+
+<!-- MARKDOWN LINKS & IMAGES -->
+<!-- https://www.markdownguide.org/basic-syntax/#reference-style-links -->
+[downloads-shield]: https://img.shields.io/github/downloads/phalado/Search-tree
+[downloads-url]: https://github.com/ferreirati/mv-08-htmlcss-framework/graphs/contributors
+
+[forks-shield]: https://img.shields.io/github/forks/phalado/Search-tree
+[forks-url]: https://github.com/phalado/Search-tree/network/members
+
+[stars-shield]: https://img.shields.io/github/stars/phalado/Search-tree
+[stars-url]: https://github.com/phalado/Search-tree/stargazers
+
+[issues-shield]: https://img.shields.io/github/issues/phalado/Search-tree
+[issues-url]: https://github.com/phalado/Search-tree/issues
+
+[docs-shield]: http://inch-ci.org/github/phalado/Search-tree.svg?branch=master
+[docs-url]: http://inch-ci.org/github/phalado/Search-tree
+
+[twitter-shield]: https://img.shields.io/twitter/url?url=https%3A%2F%2Fgithub.com%2Fphalado%2FSearch-tree%2F
+[twitter-url]: https://twitter.com/Phalado
+[article-url]: https://medium.com/p/bdfe7069be2d/
+[medium-phalado]: https://medium.com/@phalado
+[gem-file]: http://.com/
+[linkedin-url]: https://www.linkedin.com/in/raphael-cordeiro/
+[my-portfolio]: https://phalado.github.io/
+
+[product-screenshot]: images/screenshot.png

data/lib/bi-dimensional-access.rb

@@ -0,0 +1,375 @@
+class BiDimensionalTree
+  attr_reader :root
+
+  # Initialize the tree creating it's root
+  def initialize
+    @root = nil
+  end
+
+  # Create a new branch after locating it's place
+  def new_node(node, x, y, *args)
+    if @root.nil?
+      puts "Adding the node (#{x}, #{y}) in the root"
+      return @root = BiNode.new(x, y, *args)
+    elsif node.nil?
+      return node = BiNode.new(x, y, *args)
+    elsif node.x == x
+      if node.y == y
+        return node
+      elsif y < node.y
+        if node.south.nil?
+          puts "Adding the node (#{x}, #{y}) in the south of (#{node.x}, #{node.y})"
+          node.south = new_node(node.south, x, y, *args)
+        else
+          new_node(node.south, x, y, *args)
+        end
+      elsif y > node.y
+        if node.north.nil?
+          puts "Adding the node (#{x}, #{y}) in the north of (#{node.x}, #{node.y})"
+          node.north = new_node(node.north, x, y, *args)
+        else
+          new_node(node.north, x, y, *args)
+        end
+      end
+    elsif x < node.x
+      if node.west.nil?
+        puts "Adding the node (#{x}, #{y}) in the west of (#{node.x}, #{node.y})"
+        node.west = new_node(node.west, x, y, *args)
+      else
+        new_node(node.west, x, y, *args)
+      end
+    elsif x > node.x
+      if node.east.nil?
+        puts "Adding the node (#{x}, #{y}) in the east of (#{node.x}, #{node.y})"
+        node.east = new_node(node.east, x, y, *args)
+      else
+        new_node(node.east, x, y, *args)
+      end
+    end
+  end
+
+  # Create a new node and balance the tree
+  def new_node_balanced(node, x, y, *args)
+    new_node(node, x, y, *args)
+    balance
+  end
+
+  # Locate a branch, if it exists
+  def search(x, y, node = @root)
+    return false if node.nil?
+
+    if x == node.x
+      if y == node.y
+        return true
+      elsif y < node.y and !node.south.nil?
+        search(x, y, node.south)
+      elsif y > node.y and !node.north.nil?
+        search(x, y, node.north)
+      else
+        return false
+      end
+    elsif x < node.x and !node.west.nil?
+      search(x, y, node.west)
+    elsif x > node.x and !node.east.nil?
+      search(x, y, node.east)
+    else
+      return false
+    end
+  end
+
+  # Locate a branch, if it exists
+  def search_node(x, y, node = @root)
+    return nil if node.nil?
+
+    if x == node.x
+      if y == node.y
+        return node
+      elsif y < node.y and !node.south.nil?
+        search_node(x, y, node.south)
+      elsif y > node.y and !node.north.nil?
+        search_node(x, y, node.north)
+      else
+        return nil
+      end
+    elsif x < node.x and !node.west.nil?
+      search_node(x, y, node.west)
+    elsif x > node.x and !node.east.nil?
+      search_node(x, y, node.east)
+    else
+      return nil
+    end
+  end
+
+  # Edit an existing node
+  def edit_node(x, y, *args)
+    node = search_node(x, y)
+    return if node.nil?
+    node.args = args
+  end
+
+  # Load a file and create a (sub)tree with its data
+  def load_file(file)
+    data = File.open(file).readlines.map(&:chomp)
+    data.each do |d|
+      d = d.split(',')
+      new_node(@root, *d[0], *d[1], *d[2..-1]) unless d.nil?
+    end
+  end
+
+  # Save the current tree in a file
+  def save_file
+    nodes = get_nodes([])
+    file = File.open('search_tree', 'w')
+    nodes.each do |node|
+        file.puts("#{node.x} #{node.y} #{node.args}")
+    end
+    file.close
+  end
+
+  # Print all the branchs
+  def print_tree(node = @root)
+    return if node.nil?
+    print_tree(node.west) unless node.west.nil?
+    print_tree(node.south) unless node.south.nil?
+    puts "#{node.x} #{node.y} #{node.args}"
+    print_tree(node.north) unless node.north.nil?
+    print_tree(node.east) unless node.east.nil?
+    return
+  end
+
+  # Delete a selected node from the tree
+  def delete_node(x, y)
+    node = search_node(x, y)
+    nodes = get_nodes_horiz([])
+    if nodes.include? node
+      nodes.delete(node)
+      @root = nodes[nodes.length / 2]
+      @root.west = nil
+      @root.east = nil
+
+      @root.west = new_balance_nodes_horiz(nodes[0..(nodes.length / 2) - 1])
+      @root.east = new_balance_nodes_horiz(nodes[(nodes.length / 2) + 1..-1])
+    else
+      nodes = get_column(node)
+      nodes.delete(node)
+      middle = nodes[nodes.length / 2]
+      middle.south = nil
+      middle.north = nil
+
+      middle.south = new_balance_nodes_vert(nodes[0..(nodes.length / 2) - 1])
+      middle.north = new_balance_nodes_vert(nodes[(nodes.length / 2) + 1..-1])
+    end
+  end
+
+  # Balance the tree
+  def balance_vert(node = @root)
+    unless balanced_vert_helper(node)
+      balance_vert_helper(node, node)
+    end
+    unless node.east.nil?
+      unless balanced_vert_helper(node.east)
+        node.east = balance_vert_helper(node.east, node.east)
+      else
+        balance_vert(node.east)
+      end
+    end
+    unless node.west.nil?
+      unless balanced_vert_helper(node.west)
+        node.west = balance_vert_helper(node.west, node.west)
+      else
+        balance_vert(node.west)
+      end
+    end
+  end
+
+  def balance_horiz(node = @root)
+    return if balanced_horiz?
+
+    nodes = get_nodes_horiz([], node)
+
+    @root = nodes[nodes.length / 2]
+    @root.west = nil
+    @root.east = nil
+
+    @root.west = new_balance_nodes_horiz(nodes[0..(nodes.length / 2) - 1])
+    @root.east = new_balance_nodes_horiz(nodes[(nodes.length / 2) + 1..-1])
+  end
+
+  # Return true if tree is balanced, in other word,
+  # if the number of branchs is smaller than 2 raised
+  # to the tree's depth
+  def balanced_horiz?
+    number_nodes_horiz.between?(2**(get_depth_horiz - 1), 2**get_depth_horiz)
+  end
+
+  def balanced_vert?(node = @root)
+    return false unless balanced_vert_helper(node)
+    unless node.east.nil?
+      return false unless balanced_vert?(node.east)
+    end
+    unless node.west.nil?
+      return false unless balanced_vert?(node.west)
+    end
+    true
+  end
+
+  def balance
+    balance_horiz unless balanced_horiz?
+    balance_vert unless balanced_vert?
+  end
+
+  def balanced_tree
+    return false unless balanced_horiz?
+    return false unless balanced_vert?
+    true
+  end
+
+  # Return the max depth of the tree
+  def get_depth_horiz(node = @root, depth = 1, maxdepth = 0)
+    unless node.west.nil?
+      maxdepth = get_depth_horiz(node.west, depth + 1, maxdepth)
+    end
+
+    unless node.east.nil?
+      maxdepth = get_depth_horiz(node.east, depth + 1, maxdepth)
+    end
+
+    if node.west.nil? and node.east.nil? and depth > maxdepth
+      maxdepth = depth
+    end
+
+    maxdepth
+  end
+
+  def get_depth_vert(node = @root, depth = 1, maxdepth = 0)
+    unless node.south.nil?
+      maxdepth = get_depth_vert(node.south, depth + 1, maxdepth)
+    end
+
+    unless node.north.nil?
+      maxdepth = get_depth_vert(node.north, depth + 1, maxdepth)
+    end
+
+    if node.south.nil? and node.north.nil? and depth > maxdepth
+      maxdepth = depth
+    end
+
+    maxdepth
+  end
+
+  # Return the number of branchs
+  def number_nodes_horiz(node = @root)
+    if node.nil?
+      0
+    else
+      1 +
+      number_nodes_horiz(node.west) +
+      number_nodes_horiz(node.east)
+    end
+  end
+
+  def number_nodes_vert(node = @root)
+    if node.nil?
+      0
+    else
+      1 +
+      number_nodes_vert(node.south) +
+      number_nodes_vert(node.north)
+    end
+  end
+
+  def number_nodes_total(node = @root)
+    if node.nil?
+      0
+    else
+      1 +
+      number_nodes_total(node.west)  +
+      number_nodes_total(node.east)  +
+      number_nodes_total(node.south) +
+      number_nodes_total(node.north)
+    end
+  end
+
+  private
+
+  # Return all the nodes in crescent order
+  def get_nodes_horiz(nodes, node = @root)
+    nodes = get_nodes_horiz(nodes, node.west) unless node.west.nil?
+    nodes << node
+    nodes = get_nodes_horiz(nodes, node.east) unless node.east.nil?
+    return nodes
+  end
+
+  def new_balance_nodes_horiz(nodes)
+    return nil if nodes.empty?
+
+    new_middle = nodes[nodes.length / 2]
+    new_middle.east = nil
+    new_middle.west = nil
+
+    return new_middle if nodes.length == 1
+
+    new_middle.west = new_balance_nodes_horiz(nodes[0..(nodes.length / 2) - 1])
+    new_middle.east = new_balance_nodes_horiz(nodes[(nodes.length / 2) + 1..-1])
+
+    return new_middle
+  end
+
+  def get_nodes_vert(nodes, node = @root)
+    nodes = get_nodes_vert(nodes, node.south) unless node.south.nil?
+    nodes << node
+    nodes = get_nodes_vert(nodes, node.north) unless node.north.nil?
+    return nodes
+  end
+
+  def balance_vert_helper(node, partial_root)
+    nodes = get_nodes_vert([], node)
+
+    middle = nodes[nodes.length / 2]
+    if partial_root.east
+      middle.east = partial_root.east
+      partial_root.east = nil
+    end
+    if partial_root.west
+      middle.west = partial_root.west
+      partial_root.west = nil
+    end
+    middle.north = nil
+    middle.south = nil
+
+    middle.south = new_balance_nodes_vert(nodes[0..(nodes.length / 2) - 1])
+    middle.north = new_balance_nodes_vert(nodes[(nodes.length / 2) + 1..-1])
+
+    return middle
+  end
+
+  def new_balance_nodes_vert(nodes)
+    return nil if nodes.empty?
+
+    new_middle = nodes[nodes.length / 2]
+    new_middle.north = nil
+    new_middle.south = nil
+
+    return new_middle if nodes.length == 1
+
+    new_middle.south = new_balance_nodes_vert(nodes[0..(nodes.length / 2) - 1])
+    new_middle.north = new_balance_nodes_vert(nodes[(nodes.length / 2) + 1..-1])
+
+    return new_middle
+  end
+
+  def balanced_vert_helper(node)
+    number_nodes_vert(node).between?(2**(get_depth_vert(node) - 1), 2**get_depth_vert(node))
+  end
+
+  def get_column(node, middle = @root)
+    return [] if middle.nil?
+    nodes = get_nodes_vert([], middle)
+    return nodes if nodes.include? node
+    nodes = get_column(node, middle.west) unless middle.west.nil?
+    return nodes if nodes.include? node
+    nodes = get_column(node, middle.east) unless middle.east.nil?
+    return nodes if nodes.include? node
+    return []
+  end
+end

data/lib/bi-dimensional-node.rb

@@ -0,0 +1,12 @@
+class BiNode
+  attr_reader :x, :y
+  attr_accessor :east, :west, :north, :south, :args
+
+  # Create the tree's root with the base values x
+  # and y and an unkown number of arguments.
+  def initialize(x, y, *args)
+    @x    = x
+    @y    = y
+    @args = args
+  end
+end

data/lib/binary-tree-access.rb

@@ -0,0 +1,153 @@
+class BinaryTree
+  attr_reader :root
+
+  # Initialize the tree creating it's root
+  def initialize
+    @root = nil
+  end
+
+  # Create a new branch after locating it's place
+  def new_node(node, x, *args)
+    return @root = Node.new(x, *args) if @root.nil?
+    return Node.new(x, *args) if node.nil?
+    return node if node.x == x
+
+    if x < node.x
+      if node.west.nil?
+        node.west = new_node(node.west, x, *args)
+      else
+        new_node(node.west, x, *args)
+      end
+    elsif node.east.nil?
+      node.east = new_node(node.east, x, *args)
+    else
+      new_node(node.east, x, *args)
+    end
+  end
+
+  # Create a new node and balance the tree
+  def new_node_balanced(node, x, *args)
+    new_node(node, x, *args)
+    balance unless balanced?
+  end
+
+  # Edit an existing node
+  def edit_node(x, *args)
+    node = search_node(x)
+    return if node.nil?
+    node.args = args
+  end
+
+  # Load a file and create a (sub)tree with its data
+  def load_file(file)
+    data = File.open(file).readlines.map(&:chomp)
+    data.each do |d|
+      d = d.split(',')
+      new_node(@root, *d[0], *d[1..-1]) unless d.nil?
+    end
+  end
+
+  # Save the current tree in a file
+  def save_file
+    nodes = get_nodes([])
+    file = File.open('search_tree', 'w')
+    nodes.each do |node|
+      file.puts("#{node.x} #{node.args}")
+    end
+    file.close
+  end
+
+  # Delete a selected node from the tree
+  def delete_node(x)
+    nodes = get_nodes([])
+    node = search_node(x)
+    nodes.delete(node) if nodes.include? node
+    @root = nil
+    new_balance_nodes(nodes, @root)
+  end
+
+  # Locate a branch, if it exists
+  def search(x, node = @root)
+    return false if node.nil?
+
+    if x == node.x
+      return true
+    elsif x < node.x && !node.west.nil?
+      search(x, node.west)
+    elsif x > node.x && !node.east.nil?
+      search(x, node.east)
+    else
+      return false
+    end
+  end
+
+  # Locate a branch, if it exists
+  def search_node(x, node = @root)
+    return nil if node.nil?
+
+    if x == node.x
+      return node
+    elsif x < node.x && !node.west.nil?
+      search_node(x, node.west)
+    elsif x > node.x && !node.east.nil?
+      search_node(x, node.east)
+    else
+      return nil
+    end
+  end
+
+  # Print all the branchs
+  def print_tree(node = @root)
+    return if node.nil?
+    print_tree(node.west) unless node.west.nil?
+    puts "#{node.x} #{node.args}"
+    print_tree(node.east) unless node.east.nil?
+  end
+
+  # Return all the nodes in crescent order
+  def get_nodes(nodes, node = @root)
+    nodes = get_nodes(nodes, node.west) unless node.west.nil?
+    nodes << node
+    nodes = get_nodes(nodes, node.east) unless node.east.nil?
+    nodes
+  end
+
+  # Balance the tree
+  def balance
+    unless balanced?
+      nodes = get_nodes([])
+      @root = nil
+      new_balance_nodes(nodes, @root)
+    end
+  end
+
+  def new_balance_nodes(nodes, newroot = @root)
+    # p nodes
+    return if nodes.empty?
+    new_node(newroot, nodes[nodes.length / 2].x, *nodes[nodes.length / 2].args)
+    return if nodes.length == 1
+    new_balance_nodes(nodes[0..(nodes.length / 2) - 1], @root)
+    new_balance_nodes(nodes[(nodes.length / 2) + 1..-1], @root)
+  end
+
+  # Return true if tree is balanced, in other word,
+  # if the number of branchs is smaller than 2 raised
+  # to the tree's depth
+  def balanced?
+    number_nodes.between?(2**(get_depth - 1), 2**get_depth)
+  end
+
+  # Return the max depth of the tree
+  def get_depth(node = @root, depth = 1, maxdepth = 0)
+    maxdepth = get_depth(node.west, depth + 1, maxdepth) unless node.west.nil?
+    maxdepth = get_depth(node.east, depth + 1, maxdepth) unless node.east.nil?
+    maxdepth = depth if node.west.nil? && node.east.nil? && depth > maxdepth
+
+    maxdepth
+  end
+
+  # Return the number of branchs
+  def number_nodes(node = @root)
+    node.nil? ? 0 : 1 + number_nodes(node.west) + number_nodes(node.east)
+  end
+end

data/lib/binary-tree-node.rb

@@ -0,0 +1,11 @@
+class Node
+  attr_reader :x
+  attr_accessor :east, :west, :args
+
+  # Create the tree's root with the base value x
+  # and an unkown number of arguments.
+  def initialize(x, *args)
+    @x    = x
+    @args = args
+  end
+end

data/lib/search_tree.rb

@@ -0,0 +1,4 @@
+require './lib/binary-tree-access.rb'
+require './lib/binary-tree-node.rb'
+require './lib/bi-dimensional-node.rb'
+require './lib/bi-dimensional-access.rb'

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: search_tree
+version: !ruby/object:Gem::Version
+  version: 1.1.0.2
+platform: ruby
+authors:
+- "@Phalado"
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-01 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: phalado@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/bi-dimensional-access.rb
+- lib/bi-dimensional-node.rb
+- lib/binary-tree-access.rb
+- lib/binary-tree-node.rb
+- lib/search_tree.rb
+homepage: https://github.com/phalado/Search-tree/
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Open-source binary and bi-dimensional tree for ruby.
+test_files: []