puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/functions/match.rb

@@ -0,0 +1,102 @@
+# Returns the match result of matching a String or Array[String] with one of:
+#
+# * Regexp
+# * String - transformed to a Regexp
+# * Pattern type
+# * Regexp type
+#
+# Returns An Array with the entire match at index 0, and each subsequent submatch at index 1-n.
+# If there was no match, nil (ie. undef) is returned. If the value to match is an Array, a array
+# with mapped match results is returned.
+#
+# @example matching
+#   "abc123".match(/([a-z]+)[1-9]+/)  # => ["abc"]
+#   "abc123".match(/([a-z]+)([1-9]+)/)  # => ["abc", "123"]
+#
+# See the documentation for "The Puppet Type System" for more information about types.
+# @since 3.7.0
+#
+Puppet::Functions.create_function(:match) do
+  dispatch :match do
+    param 'String', 'string'
+    param 'Variant[Any, Type]', 'pattern'
+  end
+
+  dispatch :enumerable_match do
+    param 'Array[String]', 'string'
+    param 'Variant[Any, Type]', 'pattern'
+  end
+
+  def initialize(closure_scope, loader)
+    super
+
+    # Make this visitor shared among all instantiations of this function since it is faster.
+    # This can be used because it is not possible to replace
+    # a puppet runtime (where this function is) without a reboot. If you model a function in a module after
+    # this class, use a regular instance variable instead to enable reloading of the module without reboot
+    #
+    @@match_visitor   ||= Puppet::Pops::Visitor.new(self, "match", 1, 1)
+  end
+
+  # Matches given string against given pattern and returns an Array with matches.
+  # @param string [String] the string to match
+  # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
+  # @return [Array<String>] matches where first match is the entire match, and index 1-n are captures from left to right
+  #
+  def match(string, pattern)
+    @@match_visitor.visit_this_1(self, pattern, string)
+  end
+
+  # Matches given Array[String] against given pattern and returns an Array with mapped match results.
+  #
+  # @param array [Array<String>] the array of strings to match
+  # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
+  # @return [Array<Array<String, nil>>] Array with matches (see {#match}), non matching entries produce a nil entry
+  #
+  def enumerable_match(array, pattern)
+    array.map {|s| match(s, pattern) }
+  end
+
+  protected
+
+  def match_Object(obj, s)
+    msg = "match() expects pattern of T, where T is String, Regexp, Regexp[r], Pattern[p], or Array[T]. Got #{obj.class}"
+    raise ArgumentError, msg
+  end
+
+  def match_String(pattern_string, s)
+    do_match(s, Regexp.new(pattern_string))
+  end
+
+  def match_Regexp(regexp, s)
+    do_match(s, regexp)
+  end
+
+  def match_PRegexpType(regexp_t, s)
+    raise ArgumentError, "Given Regexp Type has no regular expression" unless regexp_t.pattern
+    do_match(s, regexp_t.regexp)
+  end
+
+  def match_PPatternType(pattern_t, s)
+    # Since we want the actual match result (not just a boolean), an iteration over
+    # Pattern's regular expressions is needed. (They are of PRegexpType)
+    result = nil
+    pattern_t.patterns.find {|pattern| result = match(s, pattern) }
+    result
+  end
+
+  # Returns the first matching entry
+  def match_Array(array, s)
+    result = nil
+    array.flatten.find {|entry| result = match(s, entry) }
+    result
+  end
+
+  private
+
+  def do_match(s, regexp)
+    if result = regexp.match(s)
+      result.to_a
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/functions/reduce.rb

@@ -0,0 +1,94 @@
+# Applies a parameterized block to each element in a sequence of entries from the first
+# argument (_the enumerable_) and returns the last result of the invocation of the parameterized block.
+#
+# This function takes two mandatory arguments: the first should be an Array, Hash, or something of
+# enumerable type, and the last a parameterized block as produced by the puppet syntax:
+#
+#       $a.reduce |$memo, $x| { ... }
+#       reduce($a) |$memo, $x| { ... }
+#
+# When the first argument is an Array or someting of an enumerable type, the block is called with each entry in turn.
+# When the first argument is a hash each entry is converted to an array with `[key, value]` before being
+# fed to the block. An optional 'start memo' value may be supplied as an argument between the array/hash
+# and mandatory block.
+#
+#       $a.reduce(start) |$memo, $x| { ... }
+#       reduce($a, start) |$memo, $x| { ... }
+#
+# If no 'start memo' is given, the first invocation of the parameterized block will be given the first and second
+# elements of the enumeration, and if the enumerable has fewer than 2 elements, the first
+# element is produced as the result of the reduction without invocation of the block.
+#
+# On each subsequent invocation, the produced value of the invoked parameterized block is given as the memo in the
+# next invocation.
+#
+# @example Using reduce
+#
+#       # Reduce an array
+#       $a = [1,2,3]
+#       $a.reduce |$memo, $entry| { $memo + $entry }
+#       #=> 6
+#
+#       # Reduce hash values
+#       $a = {a => 1, b => 2, c => 3}
+#       $a.reduce |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
+#       #=> [sum, 6]
+#
+#       # reverse a string
+#       "abc".reduce |$memo, $char| { "$char$memo" }
+#       #=>"cbe"
+#
+# It is possible to provide a starting 'memo' as an argument.
+#
+# @example Using reduce with given start 'memo'
+#
+#       # Reduce an array
+#       $a = [1,2,3]
+#       $a.reduce(4) |$memo, $entry| { $memo + $entry }
+#       #=> 10
+#
+#       # Reduce hash values
+#       $a = {a => 1, b => 2, c => 3}
+#       $a.reduce([na, 4]) |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
+#       #=> [sum, 10]
+#
+# @example Using reduce with an Integer range
+#
+#       Integer[1,4].reduce |$memo, $x| { $memo + $x }
+#       #=> 10
+#
+# @since 3.2 for Array and Hash
+# @since 3.5 for additional enumerable types
+# @note requires `parser = future`.
+#
+Puppet::Functions.create_function(:reduce) do
+
+  dispatch :reduce_without_memo do
+    param 'Any', :enumerable
+    required_block_param 'Callable[2,2]', :block
+  end
+
+  dispatch :reduce_with_memo do
+    param 'Any', :enumerable
+    param 'Any', :memo
+    required_block_param 'Callable[2,2]', :block
+  end
+
+  def reduce_without_memo(enumerable, pblock)
+    enum = asserted_enumerable(enumerable)
+    enum.reduce {|memo, x| pblock.call(nil, memo, x) }
+  end
+
+  def reduce_with_memo(enumerable, given_memo, pblock)
+    enum = asserted_enumerable(enumerable)
+    enum.reduce(given_memo) {|memo, x| pblock.call(nil, memo, x) }
+  end
+
+  def asserted_enumerable(obj)
+    unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
+      raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
+    end
+    enum
+  end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/functions/slice.rb

@@ -0,0 +1,126 @@
+# Applies a parameterized block to each _slice_ of elements in a sequence of selected entries from the first
+# argument and returns the first argument, or if no block is given returns a new array with a concatenation of
+# the slices.
+#
+# This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
+# enumerable type (integer, Integer range, or String), and the second, `$n`, the number of elements to include
+# in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:
+#
+#     $a.slice($n) |$x| { ... }
+#     slice($a) |$x| { ... }
+#
+# The parameterized block should have either one parameter (receiving an array with the slice), or the same number
+# of parameters as specified by the slice size (each parameter receiving its part of the slice).
+# In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining
+# elements. When the block has multiple parameters, excess parameters are set to undef for an array or
+# enumerable type, and to empty arrays for a Hash.
+#
+#     $a.slice(2) |$first, $second| { ... }
+#
+# When the first argument is a Hash, each `key,value` entry is counted as one, e.g, a slice size of 2 will produce
+# an array of two arrays with key, and value.
+#
+# @example Using slice with Hash
+#
+#     $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
+#     $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
+#
+# When called without a block, the function produces a concatenated result of the slices.
+#
+# @example Using slice without a block
+#
+#     slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
+#     slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
+#     slice(4,2)              # produces [[0,1], [2,3]]
+#     slice('hello',2)        # produces [[h, e], [l, l], [o]]
+#
+# @since 3.2 for Array and Hash
+# @since 3.5 for additional enumerable types
+# @note requires `parser = future`.
+#
+Puppet::Functions.create_function(:slice) do
+  dispatch :slice_Hash do
+    param 'Hash[Any, Any]', :hash
+    param 'Integer[1, default]', :slize_size
+    optional_block_param
+  end
+
+  dispatch :slice_Enumerable do
+    param 'Any', :enumerable
+    param 'Integer[1, default]', :slize_size
+    optional_block_param
+  end
+
+  def slice_Hash(hash, slice_size, pblock = nil)
+    result = slice_Common(hash, slice_size, [], pblock)
+    pblock ? hash : result
+  end
+
+  def slice_Enumerable(enumerable, slice_size, pblock = nil)
+    enum = asserted_enumerable(enumerable)
+    result = slice_Common(enum, slice_size, nil, pblock)
+    pblock ? enumerable : result
+  end
+
+  def slice_Common(o, slice_size, filler, pblock)
+    serving_size = asserted_slice_serving_size(pblock, slice_size)
+
+    enumerator = o.each_slice(slice_size)
+    result = []
+    if serving_size == 1
+      begin
+        if pblock
+          loop do
+            pblock.call(nil, enumerator.next)
+          end
+        else
+          loop do
+            result << enumerator.next
+          end
+        end
+      rescue StopIteration
+      end
+    else
+      begin
+        loop do
+          a = enumerator.next
+          if a.size < serving_size
+            a = a.dup.fill(filler, a.length...serving_size)
+          end
+          pblock.call(nil, *a)
+        end
+      rescue StopIteration
+      end
+    end
+    if pblock
+      o
+    else
+      result
+    end
+  end
+
+  def asserted_slice_serving_size(pblock, slice_size)
+    if pblock
+      serving_size = pblock.last_captures_rest? ? slice_size : pblock.parameter_count
+    else
+      serving_size = 1
+    end
+    if serving_size == 0
+      raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
+    end
+    unless serving_size == 1 || serving_size == slice_size
+      raise ArgumentError, "slice(): block must define one parameter, or " +
+        "the same number of parameters as the given size of the slice (#{slice_size}). Block has #{serving_size}; "+
+      pblock.parameter_names.join(', ')
+    end
+    serving_size
+  end
+
+  def asserted_enumerable(obj)
+    unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
+      raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
+    end
+    enum
+  end
+
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/functions/with.rb

@@ -0,0 +1,23 @@
+# Call a lambda with the given arguments. Since the parameters of the lambda
+# are local to the lambda's scope, this can be used to create private sections
+# of logic in a class so that the variables are not visible outside of the
+# class.
+#
+# @example Using with
+#
+#     # notices the array [1, 2, 'foo']
+#     with(1, 2, 'foo') |$x, $y, $z| { notice [$x, $y, $z] }
+#
+# @since 3.7.0
+#
+Puppet::Functions.create_function(:with) do
+  dispatch :with do
+    param 'Any', 'arg'
+    arg_count(0, :default)
+    required_block_param
+  end
+
+  def with(*args)
+    args[-1].call({}, *args[0..-2])
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/graph.rb

@@ -0,0 +1,11 @@
+module Puppet::Graph
+  require 'puppet/graph/prioritizer'
+  require 'puppet/graph/sequential_prioritizer'
+  require 'puppet/graph/title_hash_prioritizer'
+  require 'puppet/graph/random_prioritizer'
+
+  require 'puppet/graph/simple_graph'
+  require 'puppet/graph/rb_tree_map'
+  require 'puppet/graph/key'
+  require 'puppet/graph/relationship_graph'
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/graph/key.rb

@@ -0,0 +1,26 @@
+# Sequential, nestable keys for tracking order of insertion in "the graph"
+# @api private
+class Puppet::Graph::Key
+  include Comparable
+
+  attr_reader :value
+  protected :value
+
+  def initialize(value = [0])
+    @value = value
+  end
+
+  def next
+    next_values = @value.clone
+    next_values[-1] += 1
+    Puppet::Graph::Key.new(next_values)
+  end
+
+  def down
+    Puppet::Graph::Key.new(@value + [0])
+  end
+
+  def <=>(other)
+    @value <=> other.value
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/graph/prioritizer.rb

@@ -0,0 +1,29 @@
+# Base, template method, class for Prioritizers. This provides the basic
+# tracking facilities used.
+#
+# @api private
+class Puppet::Graph::Prioritizer
+  def initialize
+    @priority = {}
+  end
+
+  def forget(key)
+    @priority.delete(key)
+  end
+
+  def record_priority_for(key, priority)
+    @priority[key] = priority
+  end
+
+  def generate_priority_for(key)
+    raise NotImplementedError
+  end
+
+  def generate_priority_contained_in(container, key)
+    raise NotImplementedError
+  end
+
+  def priority_of(key)
+    @priority[key]
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/graph/random_prioritizer.rb

@@ -0,0 +1,16 @@
+# Assign a random priority to items.
+#
+# @api private
+class Puppet::Graph::RandomPrioritizer < Puppet::Graph::Prioritizer
+  def generate_priority_for(key)
+    if priority_of(key).nil?
+      record_priority_for(key, SecureRandom.uuid)
+    else
+      priority_of(key)
+    end
+  end
+
+  def generate_priority_contained_in(container, key)
+    generate_priority_for(key)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/graph/rb_tree_map.rb

@@ -0,0 +1,388 @@
+# Algorithms and Containers project is Copyright (c) 2009 Kanwei Li
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the 'Software'), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+# A RbTreeMap is a map that is stored in sorted order based on the order of its keys. This ordering is
+# determined by applying the function <=> to compare the keys. No duplicate values for keys are allowed,
+# so duplicate values are overwritten.
+#
+# A major advantage of RBTreeMap over a Hash is the fact that keys are stored in order and can thus be
+# iterated over in order. This is useful for many datasets.
+#
+# The implementation is adapted from Robert Sedgewick's Left Leaning Red-Black Tree implementation,
+# which can be found at http://www.cs.princeton.edu/~rs/talks/LLRB/Java/RedBlackBST.java
+#
+# Most methods have O(log n) complexity.
+
+class Puppet::Graph::RbTreeMap
+  include Enumerable
+
+  attr_reader :size
+
+  alias_method :length, :size
+
+  # Create and initialize a new empty TreeMap.
+  def initialize
+    @root = nil
+    @size = 0
+  end
+
+  # Insert an item with an associated key into the TreeMap, and returns the item inserted
+  #
+  # Complexity: O(log n)
+  #
+  # map = Containers::TreeMap.new
+  # map.push("MA", "Massachusetts") #=> "Massachusetts"
+  # map.get("MA") #=> "Massachusetts"
+  def push(key, value)
+    @root = insert(@root, key, value)
+    @root.color = :black
+    value
+  end
+  alias_method :[]=, :push
+
+  # Return true if key is found in the TreeMap, false otherwise
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.has_key?("GA") #=> true
+  #   map.has_key?("DE") #=> false
+  def has_key?(key)
+    !get_recursive(@root, key).nil?
+  end
+
+  # Return the item associated with the key, or nil if none found.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.get("GA") #=> "Georgia"
+  def get(key)
+    node = get_recursive(@root, key)
+    node ? node.value : nil
+    node.value if node
+  end
+  alias_method :[], :get
+
+  # Return the smallest key in the map.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.min_key #=> "GA"
+  def min_key
+    @root.nil? ? nil : min_recursive(@root).key
+  end
+
+  # Return the largest key in the map.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.max_key #=> "MA"
+  def max_key
+    @root.nil? ? nil : max_recursive(@root).key
+  end
+
+  # Deletes the item and key if it's found, and returns the item. Returns nil
+  # if key is not present.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.delete("MA") #=> "Massachusetts"
+  def delete(key)
+    result = nil
+    if @root
+      return unless has_key? key
+      @root, result = delete_recursive(@root, key)
+      @root.color = :black if @root
+      @size -= 1
+    end
+    result
+  end
+
+  # Returns true if the tree is empty, false otherwise
+  def empty?
+    @root.nil?
+  end
+
+  # Deletes the item with the smallest key and returns the item. Returns nil
+  # if key is not present.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.delete_min #=> "Massachusetts"
+  #   map.size #=> 1
+  def delete_min
+    result = nil
+    if @root
+      @root, result = delete_min_recursive(@root)
+      @root.color = :black if @root
+      @size -= 1
+    end
+    result
+  end
+
+  # Deletes the item with the largest key and returns the item. Returns nil
+  # if key is not present.
+  #
+  # Complexity: O(log n)
+  #
+  #   map = Containers::TreeMap.new
+  #   map.push("MA", "Massachusetts")
+  #   map.push("GA", "Georgia")
+  #   map.delete_max #=> "Georgia"
+  #   map.size #=> 1
+  def delete_max
+    result = nil
+    if @root
+      @root, result = delete_max_recursive(@root)
+      @root.color = :black if @root
+      @size -= 1
+    end
+    result
+  end
+
+  # Yields [key, value] pairs in order by key.
+  def each(&blk)
+    recursive_yield(@root, &blk)
+  end
+
+  def first
+    return nil unless @root
+    node = min_recursive(@root)
+    [node.key, node.value]
+  end
+
+  def last
+    return nil unless @root
+    node = max_recursive(@root)
+    [node.key, node.value]
+  end
+
+  def to_hash
+    @root ? @root.to_hash : {}
+  end
+
+  class Node # :nodoc: all
+    attr_accessor :color, :key, :value, :left, :right
+    def initialize(key, value)
+      @key = key
+      @value = value
+      @color = :red
+      @left = nil
+      @right = nil
+    end
+
+    def to_hash
+      h = {
+        :node => {
+          :key => @key,
+          :value => @value,
+          :color => @color,
+        }
+      }
+      h.merge!(:left => left.to_hash) if @left
+      h.merge!(:right => right.to_hash) if @right
+      h
+    end
+
+    def red?
+      @color == :red
+    end
+
+    def colorflip
+      @color       = @color == :red       ? :black : :red
+      @left.color  = @left.color == :red  ? :black : :red
+      @right.color = @right.color == :red ? :black : :red
+    end
+
+    def rotate_left
+      r = @right
+      r_key, r_value = r.key, r.value
+      b = r.left
+      r.left = @left
+      @left = r
+      @right = r.right
+      r.right = b
+      r.color, r.key, r.value = :red, @key, @value
+      @key, @value = r_key, r_value
+      self
+    end
+
+    def rotate_right
+      l = @left
+      l_key, l_value = l.key, l.value
+      b = l.right
+      l.right = @right
+      @right = l
+      @left = l.left
+      l.left = b
+      l.color, l.key, l.value = :red, @key, @value
+      @key, @value = l_key, l_value
+      self
+    end
+
+    def move_red_left
+      colorflip
+      if (@right.left && @right.left.red?)
+        @right.rotate_right
+        rotate_left
+        colorflip
+      end
+      self
+    end
+
+    def move_red_right
+      colorflip
+      if (@left.left && @left.left.red?)
+        rotate_right
+        colorflip
+      end
+      self
+    end
+
+    def fixup
+      rotate_left if @right && @right.red?
+      rotate_right if (@left && @left.red?) && (@left.left && @left.left.red?)
+      colorflip if (@left && @left.red?) && (@right && @right.red?)
+
+      self
+    end
+  end
+
+  private
+
+  def recursive_yield(node, &blk)
+    return unless node
+    recursive_yield(node.left, &blk)
+    yield node.key, node.value
+    recursive_yield(node.right, &blk)
+  end
+
+  def delete_recursive(node, key)
+    if (key <=> node.key) == -1
+      node.move_red_left if ( !isred(node.left) && !isred(node.left.left) )
+      node.left, result = delete_recursive(node.left, key)
+    else
+      node.rotate_right if isred(node.left)
+      if ( ( (key <=> node.key) == 0) && node.right.nil? )
+        return nil, node.value
+      end
+      if ( !isred(node.right) && !isred(node.right.left) )
+        node.move_red_right
+      end
+      if (key <=> node.key) == 0
+        result = node.value
+        min_child = min_recursive(node.right)
+        node.value = min_child.value
+        node.key = min_child.key
+        node.right = delete_min_recursive(node.right).first
+      else
+        node.right, result = delete_recursive(node.right, key)
+      end
+    end
+    return node.fixup, result
+  end
+
+  def delete_min_recursive(node)
+    if node.left.nil?
+      return nil, node.value
+    end
+    if ( !isred(node.left) && !isred(node.left.left) )
+      node.move_red_left
+    end
+    node.left, result = delete_min_recursive(node.left)
+
+    return node.fixup, result
+  end
+
+  def delete_max_recursive(node)
+    if (isred(node.left))
+      node = node.rotate_right
+    end
+    return nil, node.value if node.right.nil?
+    if ( !isred(node.right) && !isred(node.right.left) )
+      node.move_red_right
+    end
+    node.right, result = delete_max_recursive(node.right)
+
+    return node.fixup, result
+  end
+
+  def get_recursive(node, key)
+    return nil if node.nil?
+    case key <=> node.key
+    when  0 then return node
+    when -1 then return get_recursive(node.left, key)
+    when  1 then return get_recursive(node.right, key)
+    end
+  end
+
+  def min_recursive(node)
+    return node if node.left.nil?
+
+    min_recursive(node.left)
+  end
+
+  def max_recursive(node)
+    return node if node.right.nil?
+
+    max_recursive(node.right)
+  end
+
+  def insert(node, key, value)
+    unless node
+      @size += 1
+      return Node.new(key, value)
+    end
+
+    case key <=> node.key
+    when  0 then node.value = value
+    when -1 then node.left = insert(node.left, key, value)
+    when  1 then node.right = insert(node.right, key, value)
+    end
+
+    node.rotate_left if (node.right && node.right.red?)
+    node.rotate_right if (node.left && node.left.red? && node.left.left && node.left.left.red?)
+    node.colorflip if (node.left && node.left.red? && node.right && node.right.red?)
+    node
+  end
+
+  def isred(node)
+    return false if node.nil?
+
+    node.color == :red
+  end
+end