ruby_extended 1.1.0

data/lib/ruby_extended.rb

@@ -0,0 +1,5 @@
+require 'ruby_extended/array'
+require 'ruby_extended/hash'
+require 'ruby_extended/number'
+require 'ruby_extended/object'
+require 'ruby_extended/string'

data/lib/ruby_extended/array.rb

@@ -0,0 +1,197 @@
+class Array
+  require 'unicode_utils'
+
+
+  def sort_lv(&block)
+    lang = [
+      %w[e ē], %w[u ū], %w[i ī], %w[a ā], %w[s š], %w[g ģ], %w[k ķ], %w[l ļ],
+      %w[z ž], %w[c č], %w[n ņ], %w[E Ē], %w[U Ū], %w[I I], %w[A Ā], %w[S Š],
+      %w[G Ģ], %w[K Ķ], %w[L Ļ], %w[Z Ž], %w[C Č], %w[N Ņ]
+    ]
+
+    self.sort_by do |item|
+      value = (block_given? ? yield(item) : item)
+      lang.each do |en, lv|
+        value = UnicodeUtils.downcase(value).gsub(lv, en)
+      end
+      value
+    end
+  end
+
+
+  def tabulate(num, o = {})
+    return nil  if num < 1
+    return self if num == 1
+
+    split_by  = o.has_key?(:split_by)  ? o[:split_by]  : :columns
+    direction = o.has_key?(:direction) ? o[:direction] : :horizontal
+    arr, res  = self, []
+    i         = (arr.length / num.to_f).round
+
+    if direction == :horizontal
+      ii = 0
+
+      if split_by == :columns
+        rows  = ( (i == 1)   ? [0] : (0..i - 1).to_a   )
+        cells = ( (num == 1) ? [0] : (0..num - 1).to_a )
+      end
+
+      if split_by == :rows
+        rows  = ( (num == 1) ? [0] : (0..num - 1).to_a )
+        cells = ( (i == 1)   ? [0] : (0..i - 1).to_a   )
+      end
+
+      rows.each do |row_i|
+        cells.each do |cell_i|
+          res[row_i]         = [] if res[row_i].nil?
+          res[row_i][cell_i] = arr[ii]
+          ii                 = ii + 1
+        end
+      end
+
+      res
+    end
+
+    if direction == :vertical
+
+      if split_by == :columns
+        (0..(i - 1)).to_a.each do |r_i|
+          res[r_i] = (r_i).step(arr.size * 5, i).to_a.slice(0, num).map {|ii| arr[ii]}
+        end
+      end
+
+      if split_by == :rows
+        (0..(num - 1)).to_a.each do |r_i|
+          res[r_i] = (r_i).step(arr.length * 5, num).to_a.slice(0, i).map {|ii| arr[ii]}
+        end
+      end
+    end
+
+    res
+  end
+
+
+  def sample_index(count=1, offset: nil)
+    indexes = (0..(self.length - 1)).to_a
+    indexes = indexes.slice(offset + 1, indexes.length) if offset
+    return nil if indexes.nil?
+    result = indexes.sample(count)
+    result = result.first if count == 1
+    result
+  end
+
+
+  def uniq_by_key(key)
+    keys, res, found = [], [], false
+    self.each do |item|
+      found = true if item.has_key?(key)
+      next if keys.include?(item[key])
+      res << item
+      keys << item[key]
+    end
+    found ? res : self
+  end
+
+
+  def duplicates(options={})
+    self.select {|e| self.count(e) > 1}.uniq.map do |v|
+      options[:full] ? { item:  v, count: self.count(v) } : v
+    end
+  end
+
+
+  def sum(o={})
+    res, str = [], false
+
+    self.map do |e|
+      ce = o[:key] ? e[o[:key]] : e
+      if o[:only_numbers]
+        res << ce if ce.is_a?(Numeric)
+      else
+        str = true if ce.kind_of?(String)
+        res << ce unless ce.nil?
+      end
+    end
+
+    str ? res.join('') : res.reduce(:+)
+  end
+
+
+  def to_tree(o = {})
+    o[:id_key]                 = :id        unless o.has_key?(:id_key)
+    o[:parent_id_key]          = :parent_id unless o.has_key?(:parent_id_key)
+    o[:children_key]           = :children  unless o.has_key?(:children_key)
+    o[:include_id]             = true       unless o.has_key?(:include_id)
+    o[:include_parent_id]      = false      unless o.has_key?(:include_parent_id)
+    o[:include_empty_children] = false      unless o.has_key?(:include_empty_children)
+    o[:to_hash]                = false      unless o.has_key?(:to_hash)
+
+    res = Array.to_tree_children_loop(nil, self, o)
+    res = Array.to_tree_hash_loop(res, o) if o[:to_hash]
+    res
+  end
+
+
+  private
+
+
+  def self.to_tree_children_loop(parent_id, items, o)
+    res = []
+
+    items.select do |n|
+      (parent_id ? n[o[:parent_id_key]] == parent_id : n[o[:parent_id_key]].nil?)
+    end.each do |item|
+      new_item                    = {}
+
+      new_item[o[:id_key]]        = item[o[:id_key]] if o[:to_hash] || o[:include_id]
+      new_item[o[:parent_id_key]] = parent_id        if o[:to_hash] || o[:include_parent_id]
+
+      item.keys.reject do |key|
+        key == o[:id_key] || key == o[:parent_id_key]
+      end.each do |key|
+        new_item[key] = item[key]
+      end
+
+      children = Array.to_tree_children_loop(item[o[:id_key]], items, o)
+
+      if children.any? || (children.length == 0 && o[:include_empty_children])
+        new_item[o[:children_key]] = children
+      end
+
+      res << new_item
+    end
+
+    res
+  end
+
+
+  def self.to_tree_hash_loop(items, o)
+    res = {}
+
+    items.each do |item|
+      res     = {}
+      id      = item[o[:id_key]]
+      res[id] = {}
+
+
+      res[id][o[:id_key]]        = item[o[:id_key]]        if o[:include_id]
+      res[id][o[:parent_id_key]] = item[o[:parent_id_key]] if o[:include_parent_id]
+
+      item.keys.reject do |key|
+        (key == o[:id_key] || key == o[:parent_id_key])
+      end.each do |key|
+        res[id][key] = item[key]
+      end
+
+      if item[o[:children_key]]
+        res[id][o[:children_key]] = Array.to_tree_hash_loop(item[o[:children_key]], o)
+      else
+        res[id][o[:children_key]] = [] if o[:include_empty_children]
+      end
+    end
+
+    res
+  end
+
+
+end

data/lib/ruby_extended/hash.rb

@@ -0,0 +1,30 @@
+class Hash
+
+
+  def deep_find(find_key)
+    Hash.deep_find_loop(self, [], find_key).flatten
+  end
+
+
+  private
+
+
+  def self.deep_find_loop(object, path, find_key)
+    found = []
+
+    if object.is_a?(Array)
+      object.each_with_index do |sub_object, index|
+        found << Hash.deep_find_loop(sub_object, path + [index], find_key)
+      end
+    elsif object.is_a?(Hash)
+      object.keys.each do |key|
+        found << {value: object[key], path: path + [key]} if key == find_key
+        found << Hash.deep_find_loop(object[key], path + [key], find_key)
+      end
+    end
+
+    found
+  end
+
+
+end

data/lib/ruby_extended/number.rb

@@ -0,0 +1,54 @@
+module NumericRubyExtended
+
+
+  def self.included(base)
+    base.class_eval do
+
+      def no_zeros
+        self.to_f.to_s.gsub(/\.0+$/, '')
+      end
+
+      def to_money
+        '%.2f' % self.to_f
+      end
+
+      def percent_of(percent, options = {})
+        result = (self.to_f / 100.to_f * percent.to_f)
+        options[:decimal] ? result : result.to_i
+      end
+
+      def get_percent_from(value, options = {})
+        result = (self.to_f / value.to_f * 100)
+        options[:decimal] ? result : result.to_i
+      end
+
+    end
+  end
+
+
+end
+
+
+class Integer
+  include NumericRubyExtended
+end
+
+
+class Float
+  include NumericRubyExtended
+end
+
+
+class BigDecimal
+  include NumericRubyExtended
+end
+
+
+class Complex
+  include NumericRubyExtended
+end
+
+
+class Rational
+  include NumericRubyExtended
+end

data/lib/ruby_extended/object.rb

@@ -0,0 +1,32 @@
+module ObjectRubyExtended
+
+
+  def self.included(base)
+    base.class_eval do
+
+      def dig(*items)
+        res, all_items = self, items.flatten
+
+        all_items.each do |item|
+          next if res.nil?
+          res = res[item] rescue nil
+        end
+
+        res
+      end
+
+    end
+  end
+
+
+end
+
+
+class Array
+  include ObjectRubyExtended
+end
+
+
+class Hash
+  include ObjectRubyExtended
+end

data/lib/ruby_extended/string.rb

@@ -0,0 +1,59 @@
+class String
+
+
+  def strip_whitespace(options = {})
+    res = self
+    res = res.gsub("\u0020", '') # SPACE (U+0020)
+    res = res.gsub("\u00A0", '') # NO-BREAK SPACE (U+00A0)
+    res = res.gsub("\u1680", '') # OGHAM SPACE MARK (U+1680)
+    res = res.gsub("\u180E", '') # MONGOLIAN VOWEL SEPARATOR (U+180E)
+    res = res.gsub("\u2000", '') # EN QUAD (U+2000)
+    res = res.gsub("\u2002", '') # EN SPACE (nut) (U+2002)
+    res = res.gsub("\u2003", '') # EM SPACE (mutton) (U+2003)
+    res = res.gsub("\u2004", '') # THREE-PER-EM SPACE (thick space) (U+2004)
+    res = res.gsub("\u2005", '') # FOUR-PER-EM SPACE (mid space) (U+2005)
+    res = res.gsub("\u2006", '') # SIX-PER-EM SPACE (U+2006)
+    res = res.gsub("\u2007", '') # FIGURE SPACE (U+2007)
+    res = res.gsub("\u2008", '') # PUNCTUATION SPACE (U+2008)
+    res = res.gsub("\u2009", '') # THIN SPACE (U+2009)
+    res = res.gsub("\u200A", '') # HAIR SPACE (U+200A)
+    res = res.gsub("\u200B", '') # ZERO WIDTH SPACE (U+200B)
+    res = res.gsub("\u200F", '') # NARROW NO-BREAK SPACE (U+200F)
+    res = res.gsub("\u205F", '') # MEDIUM MATHEMATICAL SPACE (U+205F)
+    res = res.gsub("\u3000", '') # IDEOGRAPHIC SPACE (U+3000)
+    res = res.gsub("\uFEFF", '') # ZERO WIDTH NO-BREAK SPACE (U+FEFF)
+
+    if options[:visible]
+      res = res.gsub("\u2423", '') # OPEN BOX (U+2423)
+      res = res.gsub("\u2422", '') # BLANK SYMBOL (U+2422)
+      res = res.gsub("\u2420", '') # SYMBOL FOR SPACE (U+2420)
+    end
+
+    res
+  end
+
+
+  def strip_newline
+    res = self
+    res = res.delete("\n")
+    res = res.delete("\r")
+    res
+  end
+
+
+  def index_of(str)
+    res = []
+    self.scan(/#{str}/) { |c| res << [c, $~.offset(0)[0]] }
+    res.map(&:last)
+  end
+
+
+  def similarity_percent(b)
+    longer  = [self.size, b.size].max
+    same    = self.each_char.zip(b.each_char).select { |a, b| a == b }.size
+    percent = (longer - same) / self.size.to_f
+    (100.0 - (percent * 100.to_f))
+  end
+
+
+end

data/lib/ruby_extended/version.rb

@@ -0,0 +1,3 @@
+module RubyExtended
+  VERSION = '1.1.0'
+end

data/readme.md

@@ -0,0 +1,24 @@
+# Ruby Extended
+
+![Ruby Version](badges/ruby.svg)
+![Coverage](badges/coverage.svg)
+[![License](badges/license.svg)](https://creativecommons.org/licenses/by/4.0/)
+
+Extends ruby classes with useful methods.
+
+## Documentation
+Documentation [available here](/documentation/readme.md).
+
+## Installation
+Add this line to your application's Gemfile:
+```ruby
+gem 'ruby_extended'
+```
+And then execute:
+```bash
+bundle
+```
+Or install it yourself as:
+```bash
+gem install ruby_extended
+```

data/ruby_extended.gemspec

@@ -0,0 +1,24 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'ruby_extended/version'
+
+Gem::Specification.new do |s|
+  s.name                  = 'ruby_extended'
+  s.version               = RubyExtended::VERSION.dup
+  s.platform              = Gem::Platform::RUBY
+  s.authors               = 'EdCordata'
+  s.description           = 'Extend Ruby classes with helpful methods'
+  s.summary               = 'Extend Ruby classes with helpful methods'
+  s.licenses              = ['CC BY 4.0']
+  s.files                 = `git ls-files`.split("\n")
+  s.homepage              = 'https://github.com/EdCordata-Ruby-Gems/ruby_extended'
+  s.metadata              = {
+    'documentation_uri' => 'https://github.com/EdCordata-Ruby-Gems/ruby_extended/blob/master/documentation/readme.md',
+    'source_code_uri'   => 'https://github.com/EdCordata-Ruby-Gems/ruby_extended',
+    'bug_tracker_uri'   => 'https://github.com/EdCordata-Ruby-Gems/ruby_extended/issues',
+    'wiki_uri'          => 'https://github.com/EdCordata-Ruby-Gems/ruby_extended/blob/master/documentation/readme.md',
+  }
+  s.require_paths         = ['lib']
+  s.required_ruby_version = '>= 1.9.3'
+  s.rubygems_version      = '1.6.2'
+  s.add_runtime_dependency 'unicode_utils', '~> 1'
+end

data/spec/ruby_extend_array_spec.rb

@@ -0,0 +1,412 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require_relative '../lib/ruby_extended.rb'
+
+RSpec.describe Array do
+
+
+  describe 'Array.sort_lv' do
+
+    it 'Should order Latvian special characters in array' do
+      expect(%w[a b ā c z č].sort_lv).to eql(%w[a ā b c č z])
+    end
+
+    it 'Should order Latvian characters in array while accepting block' do
+      input_arr  = [ { n: 'a' }, { n: 'c' }, { n: 'ā' }, { n: 'č' }, { n: 'z' } ]
+      output_arr = [ { n: 'a' }, { n: 'ā' }, { n: 'c' }, { n: 'č' }, { n: 'z' } ]
+
+      expect(input_arr.sort_lv { |x| x[:n] }).to eql(output_arr)
+    end
+
+  end
+
+
+  describe 'Array.tabulate' do
+    input_arr = %w[a b c d e f g]
+
+    it 'Should return nil if tabulate value is 0' do
+      expect(input_arr.tabulate(0, split_by: :columns, direction: :horizontal)).to(be_nil)
+      expect(input_arr.tabulate(0, split_by: :rows,    direction: :horizontal)).to(be_nil)
+      expect(input_arr.tabulate(0, split_by: :columns, direction: :vertical)).to(be_nil)
+      expect(input_arr.tabulate(0, split_by: :rows,    direction: :vertical)).to(be_nil)
+    end
+
+    it 'Should return nil if tabulate value is bellow 1' do
+      expect(input_arr.tabulate(-1, split_by: :columns, direction: :horizontal)).to(be_nil)
+      expect(input_arr.tabulate(-1, split_by: :rows,    direction: :horizontal)).to(be_nil)
+      expect(input_arr.tabulate(-1, split_by: :columns, direction: :vertical)).to(be_nil)
+      expect(input_arr.tabulate(-1, split_by: :rows,    direction: :vertical)).to(be_nil)
+    end
+
+    it 'Should convert array to horizontal columns with value 2 (less as input)' do
+      output = [ ['a','b'], ['c','d'], ['e','f'], ['g',nil] ]
+      expect(input_arr.tabulate(2, split_by: :columns, direction: :horizontal)).to eql(output)
+    end
+
+    it 'Should convert array to horizontal rows with value 2 (less as input)' do
+      output = [ ['a','b','c','d'], ['e','f','g',nil] ]
+      expect(input_arr.tabulate(2, split_by: :rows, direction: :horizontal)).to eql(output)
+    end
+
+    it 'Should convert array to vertical columns with value 2 (less as input)' do
+      output = [ ['a','e'], ['b','f'], ['c','g'], ['d',nil] ]
+      expect(input_arr.tabulate(2, split_by: :columns, direction: :vertical)).to eql(output)
+    end
+
+    it 'Should convert array to vertical rows with value 2 (less as input)' do
+      output = [ ['a','c','e','g'], ['b','d','f',nil] ]
+      expect(input_arr.tabulate(2, split_by: :rows, direction: :vertical)).to eql(output)
+    end
+
+    it 'Should convert array to horizontal columns with value 7 (same as input)' do
+      output = [ ['a','b','c','d','e','f','g'] ]
+      expect(input_arr.tabulate(7, split_by: :columns, direction: :horizontal)).to eql(output)
+    end
+
+    it 'Should convert array to horizontal rows with value 7 (same as input)' do
+      output = [ ['a'],['b'],['c'],['d'],['e'],['f'],['g'] ]
+      expect(input_arr.tabulate(7, split_by: :rows, direction: :horizontal)).to eql(output)
+    end
+
+    it 'Should convert array to horizontal columns with value 8 (more than input)' do
+      output = [ ['a','b','c','d','e','f','g', nil] ]
+      expect(input_arr.tabulate(8, split_by: :columns, direction: :horizontal)).to eql(output)
+    end
+
+    it 'Should convert array to horizontal rows with value 8 (more than input)' do
+      output = [ ['a'],['b'],['c'],['d'],['e'],['f'],['g'], [nil] ]
+      expect(input_arr.tabulate(8, split_by: :rows, direction: :horizontal)).to eql(output)
+    end
+
+    it 'Should convert array to horizontal columns with value 9 (more than input)' do
+      output = [ ['a','b','c','d','e','f','g', nil, nil] ]
+      expect(input_arr.tabulate(9, split_by: :columns, direction: :horizontal)).to eql(output)
+    end
+
+    it 'Should convert array to horizontal rows with value 9 (more than input)' do
+      output = [ ['a'],['b'],['c'],['d'],['e'],['f'],['g'], [nil], [nil] ]
+      expect(input_arr.tabulate(9, split_by: :rows, direction: :horizontal)).to eql(output)
+    end
+
+  end
+
+
+  describe 'Array.sample_index' do
+    input_arr = %w[a b c d e f g h]
+
+    it 'Should return random index' do
+      expect(input_arr.sample_index(1).class).to be(Integer)
+
+      expect(input_arr.sample_index(1)).to(
+        be_between(0, (input_arr.length - 1))
+      )
+    end
+
+    it 'Should return two random indexes' do
+      expect(input_arr.sample_index(2)).to be_instance_of(Array)
+
+      expect(input_arr.sample_index(2).length).to be(2)
+    end
+
+  end
+
+
+  describe 'Array.uniq_by_key' do
+    input_arr  = [ {a: 1, b: '123'}, {a: 1, b: 'abc'}, {a: 2, b: 'cde'} ]
+    output_arr = [ {a: 1, b: '123'}, {a: 2, b: 'cde'} ]
+
+    it 'Should return uniq hash items' do
+      expect(input_arr.uniq_by_key(:a)).to eql(output_arr)
+    end
+
+    it 'Should return original array if key not found' do
+      expect(input_arr.uniq_by_key(:x)).to eql(input_arr)
+    end
+
+  end
+
+
+  describe 'Array.duplicates' do
+    input_arr = ['a', 'a', 2, 2, 2, 2, 3, 'b', nil, nil]
+
+    it 'Should return array of duplicates' do
+      expect(input_arr.duplicates).to eql(['a', 2, nil])
+    end
+
+    it 'Should return hash with duplicates and count' do
+      expect(input_arr.duplicates(full: true)).to(
+        eql([
+          {item: 'a', count: 2},
+          {item: 2,   count: 4},
+          {item: nil, count: 2}
+        ])
+      )
+    end
+
+  end
+
+
+  describe 'Array.sum' do
+
+    it 'Should sum array of integers' do
+      expect( [1, 2, 3].sum ).to eq(6)
+    end
+
+    it 'Should sum array if floats' do
+      expect( [0.1, 0.2, 1].sum ).to eq(1.3)
+    end
+
+    it 'Should sum array of integers, floats and strings' do
+      expect( %w[a b].sum ).to eq('ab')
+      expect( ['a', 'b', 2, 1.5, nil].sum ).to eq('ab21.5')
+    end
+
+    it 'Should sum hash by keys' do
+      expect( [ {a: 1}, {a: 'a'}, {a: 3} ].sum(key: :a) ).to eq('1a3')
+      expect( [ {a: 1}, {a: 'a'}, {b: 3} ].sum(key: :a) ).to eq('1a')
+      expect( [ {a: 1}, {a: 2}, {b: 3} ].sum(key: :a) ).to eq(3)
+    end
+
+    it 'Should recognize Float, Integer, BigDecimal, Complex and Rational' do
+      expect( [BigDecimal(1), Float(1), Integer(1), Complex(1), Rational(1)].sum ).to eq(5)
+      expect( [BigDecimal(1), Float(1), Integer(1), Complex(1), Rational(1), 'a'].sum(only_numbers: true) ).to eq(5)
+    end
+
+    it 'Should sum only the number values if :only_numbers option provided' do
+      expect( ['a', 'b', 5].sum(only_numbers: true) ).to eq(5)
+      expect( ['a', 1, 1.5, nil].sum(only_numbers: true) ).to eq(2.5)
+    end
+
+    it 'Should sum hash by keys, but only the number values if :only_numbers option provided' do
+      expect( [ {a: 1}, {a: 'a'}, {a: 3} ].sum(key: :a, only_numbers: true) ).to eq(4)
+      expect( [ {a: 1}, {a: 'a'}, {b: 3} ].sum(key: :a, only_numbers: true) ).to eq(1)
+    end
+
+    it 'Should return nil if hash key was not found' do
+      expect( [ {a: 1}, {a: 'a'}, {a: 3} ].sum(key: :b) ).to be_nil
+    end
+
+  end
+
+
+  describe 'Array.to_tree' do
+    input_arr = [
+      {id: 1, parent_id: nil, any_other_key: 'a'},
+      {id: 2, parent_id: 1,   any_other_key: 'b'},
+      {id: 3, parent_id: 2,   any_other_key: 'c'},
+    ]
+
+    input_arr_custom_keys = [
+      {id_x: 1, parent_id_x: nil, any_other_key: 'a'},
+      {id_x: 2, parent_id_x: 1,   any_other_key: 'b'},
+      {id_x: 3, parent_id_x: 2,   any_other_key: 'c'},
+    ]
+
+    it 'Should convert array from using parent_id to array, using children sub-array' do
+      expect(input_arr.to_tree).to(
+        eq([
+             {
+               id:            1,
+               any_other_key: 'a',
+               children: [
+                   {
+                     id: 2,
+                     any_other_key: 'b',
+                     children: [ {id: 3, any_other_key: 'c'} ]
+                   }
+                 ]
+             }
+           ])
+      )
+    end
+
+    it 'Should convert array from using parent_id to array, using children sub-array but with custom keys' do
+      expect(input_arr_custom_keys.to_tree(id_key: :id_x, parent_id_key: :parent_id_x, children_key: :children_x)).to(
+        eq([
+             {
+               id_x:          1,
+               any_other_key: 'a',
+               children_x: [
+                   {
+                     id_x:          2,
+                     any_other_key: 'b',
+                     children_x:  [
+                         {id_x: 3, any_other_key: 'c'}
+                       ]
+                   }
+                 ]
+             }
+           ])
+      )
+    end
+
+    it 'Should convert array from using parent_id to array, using children sub-array but without id key' do
+      expect(input_arr.to_tree(include_id: false)).to(
+        eq([
+             {
+               any_other_key: 'a',
+               children: [
+                   {
+                     any_other_key: 'b',
+                     children:  [ {any_other_key: 'c'} ]
+                   }
+                 ]
+             }
+           ])
+      )
+    end
+
+    it 'Should convert array from using parent_id to array, using children sub-array but with parent_id key' do
+      expect(input_arr.to_tree(include_parent_id: true)).to(
+        eq([
+             {
+               id:            1,
+               any_other_key: 'a',
+               parent_id:     nil,
+               children: [
+                   {
+                     id:            2,
+                     any_other_key: 'b',
+                     parent_id:     1,
+                     children:
+                       [ {id: 3, any_other_key: 'c', parent_id: 2} ]
+                   }
+                 ]
+             }
+           ])
+      )
+    end
+
+    it 'Should convert array from using parent_id to array, using children sub-array but with empty children key' do
+      expect(input_arr.to_tree(include_empty_children: true)).to(
+        eq([
+             {
+               id:            1,
+               any_other_key: 'a',
+               children:
+                 [
+                   {
+                     id:            2,
+                     any_other_key: 'b',
+                     children:
+                       [ {id: 3, any_other_key: 'c', children: []} ]
+                   }
+                 ]
+             }
+           ])
+      )
+    end
+
+    it 'Should convert array from using parent_id to hash, using children sub-array' do
+      expect(input_arr.to_tree(to_hash: true)).to(
+        eq({
+             1 => {
+               id:            1,
+               any_other_key: 'a',
+               children:      {
+                 2 => {
+                   id:            2,
+                   any_other_key: 'b',
+                   children:  {
+                     3 => {id: 3, any_other_key: 'c'}
+                   }
+                 }
+               }
+             }
+           })
+      )
+    end
+
+    it 'Should convert array from using parent_id to hash, using children sub-array but with custom keys' do
+      expect(input_arr_custom_keys.to_tree(to_hash: true, id_key: :id_x, parent_id_key: :parent_id_x, children_key: :children_x)).to(
+        eq({
+             1 => {
+               id_x:          1,
+               any_other_key: 'a',
+               children_x:    {
+                 2 => {
+                   id_x:          2,
+                   any_other_key: 'b',
+                   children_x: {
+                       3 => {id_x: 3, any_other_key: 'c'}
+                     }
+                 }
+               }
+             }
+           })
+      )
+    end
+
+    it 'Should convert array from using parent_id to hash, using children sub-array but without id key' do
+      expect(input_arr.to_tree(to_hash: true, include_id: false)).to(
+        eq({
+             1 => {
+               any_other_key: 'a',
+               children: {
+                 2 => {
+                   any_other_key: 'b',
+                   children: {
+                       3 => {any_other_key: 'c'}
+                     }
+                 }
+               }
+             }
+           })
+      )
+    end
+
+    it 'Should convert array from using parent_id to hash, using children sub-array but with parent_id key' do
+      expect(input_arr.to_tree(to_hash: true, include_parent_id: true)).to(
+        eq({
+             1 => {
+               id:            1,
+               any_other_key: 'a',
+               parent_id:     nil,
+               children:      {
+                 2 => {
+                   id:            2,
+                   any_other_key: 'b',
+                   parent_id:     1,
+                   children:   {
+                       3 => {
+                           id:            3,
+                           any_other_key: 'c',
+                           parent_id:     2
+                         }
+                     }
+                 }
+               }
+             }
+           })
+      )
+    end
+
+    it 'Should convert array from using parent_id to hash, using children sub-array but with empty children key' do
+      expect(input_arr.to_tree(to_hash: true, include_empty_children: true)).to(
+        eq({
+             1 => {
+               id:            1,
+               any_other_key: 'a',
+               children:      {
+                 2 => {
+                   id:            2,
+                   any_other_key: 'b',
+                   children: {
+                       3 => {
+                           id:            3,
+                           any_other_key: 'c',
+                           children:      {}
+                         }
+                     }
+                 }
+               }
+             }
+           })
+      )
+    end
+
+  end
+
+
+end