puppet 2.7.6 → 2.7.8

data/lib/puppet/provider/service/redhat.rb

@@ -1,9 +1,8 @@
 # Manage Red Hat services.  Start/stop uses /sbin/service and enable/disable uses chkconfig
 
 Puppet::Type.type(:service).provide :redhat, :parent => :init, :source => :init do
-  desc "Red Hat's (and probably many others) form of `init`-style service management:
-
-  Uses `chkconfig` for service enabling and disabling.
+  desc "Red Hat's (and probably many others') form of `init`-style service
+    management. Uses `chkconfig` for service enabling and disabling.
 
   "
 

data/lib/puppet/provider/service/runit.rb

@@ -2,36 +2,36 @@
 #
 # author Brice Figureau <brice-puppet@daysofwonder.com>
 Puppet::Type.type(:service).provide :runit, :parent => :daemontools do
-  desc "Runit service management.
+  desc <<-EOT
+    Runit service management.
 
-  This provider manages daemons running supervised by Runit.
-  It tries to detect the service directory, with by order of preference:
+    This provider manages daemons running supervised by Runit.
+    When detecting the service directory it will check, in order of preference:
 
-  * /service
-  * /var/service
-  * /etc/service
+    * `/service`
+    * `/var/service`
+    * `/etc/service`
 
-  The daemon directory should be placed in a directory that can be
-  by default in:
+    The daemon directory should be in one of the following locations:
 
-  * /etc/sv
+    * `/etc/sv`
 
-  or this can be overriden in the service resource parameters::
+    or this can be overriden in the service resource parameters::
 
-      service { \"myservice\":
-        provider => \"runit\",
-        path => \"/path/to/daemons\",
-      }
+        service { "myservice":
+          provider => "runit",
+          path => "/path/to/daemons",
+        }
 
-  This provider supports out of the box:
+    This provider supports out of the box:
 
-  * start/stop
-  * enable/disable
-  * restart
-  * status
+    * start/stop
+    * enable/disable
+    * restart
+    * status
 
 
-"
+  EOT
 
   commands :sv => "/usr/bin/sv"
 

data/lib/puppet/provider/service/smf.rb

@@ -1,15 +1,16 @@
 # Solaris 10 SMF-style services.
 Puppet::Type.type(:service).provide :smf, :parent => :base do
-  desc "Support for Sun's new Service Management Framework.
+  desc <<-EOT
+    Support for Sun's new Service Management Framework.
 
-  Starting a service is effectively equivalent to enabling it, so there is
-  only support for starting and stopping services, which also enables and
-  disables them, respectively.
+    Starting a service is effectively equivalent to enabling it, so there is
+    only support for starting and stopping services, which also enables and
+    disables them, respectively.
 
-  By specifying manifest => \"/path/to/service.xml\", the SMF manifest will
-  be imported if it does not exist.
+    By specifying `manifest => "/path/to/service.xml"`, the SMF manifest will
+    be imported if it does not exist.
 
-  "
+  EOT
 
   defaultfor :operatingsystem => :solaris
 

data/lib/puppet/provider/service/src.rb

@@ -3,13 +3,12 @@ Puppet::Type.type(:service).provide :src, :parent => :base do
 
   desc "Support for AIX's System Resource controller.
 
-  Services are started/stopped based on the stopsrc and startsrc
-  commands, and some services can be refreshed with refresh command.
+  Services are started/stopped based on the `stopsrc` and `startsrc`
+  commands, and some services can be refreshed with `refresh` command.
 
-  * Enabling and disableing services is not supported, as it requires
-  modifications to /etc/inittab.
-
-  * Starting and stopping groups of subsystems is not yet supported
+  Enabling and disabling services is not supported, as it requires
+  modifications to `/etc/inittab`. Starting and stopping groups of subsystems
+  is not yet supported.
   "
 
   defaultfor :operatingsystem => :aix

data/lib/puppet/provider/service/systemd.rb

@@ -1,7 +1,7 @@
 # Manage systemd services using /bin/systemctl
 
 Puppet::Type.type(:service).provide :systemd, :parent => :base do
-  desc "Manage systemd services using /bin/systemctl"
+  desc "Manages `systemd` services using `/bin/systemctl`."
 
   commands :systemctl => "/bin/systemctl"
 

data/lib/puppet/provider/service/upstart.rb

@@ -1,10 +1,8 @@
 Puppet::Type.type(:service).provide :upstart, :parent => :init do
-  desc "Ubuntu service manager upstart.
+  desc "Ubuntu service management with `upstart`.
 
-  This provider manages upstart jobs which have replaced initd.
-
-  See:
-   * http://upstart.ubuntu.com/
+  This provider manages `upstart` jobs, which have replaced `initd` services
+  on Ubuntu. For `upstart` documentation, see <http://upstart.ubuntu.com/>.
   "
   # confine to :ubuntu for now because I haven't tested on other platforms
   confine :operatingsystem => :ubuntu #[:ubuntu, :fedora, :debian]

data/lib/puppet/provider/service/windows.rb

@@ -4,16 +4,16 @@ require 'win32/service' if Puppet.features.microsoft_windows?
 
 Puppet::Type.type(:service).provide :windows do
 
-  desc "Support for Windows Service Control Manager (SCM).
+  desc <<-EOT
+    Support for Windows Service Control Manager (SCM).
 
-  Services are controlled according to win32-service gem.
-
-  * All SCM operations (start/stop/enable/disable/query) are supported.
-
-  * Control of service groups (dependencies) is not yet supported."
+    Services are controlled according to the capabilities of the `win32-service`
+    gem. All SCM operations (start/stop/enable/disable/query) are supported.
+    Control of service groups (dependencies) is not yet supported.
+  EOT
 
   defaultfor :operatingsystem => :windows
-  confine :operatingsystem => :windows
+  confine    :operatingsystem => :windows
 
   has_feature :refreshable
 

data/lib/puppet/provider/sshkey/parsed.rb

@@ -8,11 +8,10 @@ else
 end
 
 
-      Puppet::Type.type(:sshkey).provide(
-        :parsed,
+Puppet::Type.type(:sshkey).provide(
+  :parsed,
   :parent => Puppet::Provider::ParsedFile,
   :default_target => known,
-        
   :filetype => :flat
 ) do
   desc "Parse and generate host-wide known hosts files for SSH."

data/lib/puppet/provider/user/aix.rb

@@ -17,7 +17,7 @@ require 'tempfile'
 require 'date'
 
 Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
-  desc "User management for AIX! Users are managed with mkuser, rmuser, chuser, lsuser"
+  desc "User management for AIX."
 
   # This will the the default provider for this platform
   defaultfor :operatingsystem => :aix
@@ -28,7 +28,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   commands :add       => "/usr/bin/mkuser"
   commands :delete    => "/usr/sbin/rmuser"
   commands :modify    => "/usr/bin/chuser"
-  
+
   commands :lsgroup   => "/usr/sbin/lsgroup"
   commands :chpasswd  => "/bin/chpasswd"
 
@@ -52,7 +52,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   end
 
   # AIX attributes to properties mapping.
-  # 
+  #
   # Valid attributes to be managed by this provider.
   # It is a list with of hash
   #  :aix_attr      AIX command attribute name
@@ -73,10 +73,10 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
     {:aix_attr => :minage,     :puppet_prop => :password_min_age},
     {:aix_attr => :attributes, :puppet_prop => :attributes},
   ]
-  
+
   #--------------
   # Command definition
-  
+
   # Return the IA module arguments based on the resource param ia_load_module
   def get_ia_module_args
     if @resource[:ia_load_module]
@@ -85,7 +85,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
       []
     end
   end
-  
+
   # List groups and Ids
   def lsgroupscmd(value=@resource[:name])
     [command(:lsgroup)] +
@@ -116,7 +116,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   def modifycmd(hash = property_hash)
     args = self.hash2args(hash)
     return nil if args.empty?
-    
+
     [self.class.command(:modify)] + self.get_ia_module_args +
       args + [@resource[:name]]
   end
@@ -131,9 +131,9 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
     super
     # Reset the password if needed
     self.password = @resource[:password] if @resource[:password]
-  end 
+  end
+
 
-  
   def get_arguments(key, value, mapping, objectinfo)
     # In the case of attributes, return a list of key=vlaue
     if key == :attributes
@@ -141,10 +141,10 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
         unless value and value.is_a? Hash
       return value.select { |k,v| true }.map { |pair| pair.join("=") }
     end
-        
+
     super(key, value, mapping, objectinfo)
   end
-  
+
   # Get the groupname from its id
   def self.groupname_by_id(gid)
     groupname=nil
@@ -165,16 +165,16 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
 
   # Check that a group exists and is valid
   def verify_group(value)
-    if value.is_a? Integer or value.is_a? Fixnum  
+    if value.is_a? Integer or value.is_a? Fixnum
       groupname = self.groupname_by_id(value)
       raise ArgumentError, "AIX group must be a valid existing group" unless groupname
-    else 
+    else
       raise ArgumentError, "AIX group must be a valid existing group" unless groupid_by_name(value)
       groupname = value
     end
     groupname
   end
-  
+
   # The user's primary group.  Can be specified numerically or by name.
   def gid_to_attr(value)
     verify_group(value)
@@ -186,7 +186,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
   end
 
   # The expiry date for this user. Must be provided in
-  # a zero padded YYYY-MM-DD HH:MM format 
+  # a zero padded YYYY-MM-DD HH:MM format
   def expiry_to_attr(value)
     # For chuser the expires parameter is a 10-character string in the MMDDhhmmyy format
     # that is,"%m%d%H%M%y"
@@ -197,7 +197,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
     end
     newdate
   end
-  
+
   def expiry_from_attr(value)
     if value =~ /(..)(..)(..)(..)(..)/
       #d= DateTime.parse("20#{$5}-#{$1}-#{$2} #{$3}:#{$4}")
@@ -233,7 +233,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
     if ! f.eof?
       f.each { |l|
         # If there is a new user stanza, stop
-        break if l  =~ /^\S*:\s*$/ 
+        break if l  =~ /^\S*:\s*$/
         # If the password= entry is found, return it
         if l  =~ /^\s*password\s*=\s*(.*)$/
           password = $1; break;
@@ -242,11 +242,11 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
     end
     f.close()
     return password
-  end 
+  end
 
   def password=(value)
     user = @resource[:name]
-    
+
     # Puppet execute does not support strings as input, only files.
     tmpfile = Tempfile.new('puppet_#{user}_pw')
     tmpfile << "#{user}:#{value}\n"
@@ -264,7 +264,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
     ensure
       tmpfile.delete()
     end
-  end 
+  end
 
   def filter_attributes(hash)
     # Return only not managed attributtes.
@@ -284,7 +284,7 @@ Puppet::Type.type(:user).provide :aix, :parent => Puppet::Provider::AixObject do
     #self.class.validate(param, value)
     param = :attributes
     cmd = modifycmd({param => filter_attributes(attr_hash)})
-    if cmd 
+    if cmd
       begin
         execute(cmd)
       rescue Puppet::ExecutionFailure  => detail

data/lib/puppet/provider/user/hpux.rb

@@ -1,5 +1,7 @@
 Puppet::Type.type(:user).provide :hpuxuseradd, :parent => :useradd do
-  desc "User management for hp-ux! Undocumented switch to special usermod because HP-UX regular usermod is TOO STUPID to change stuff while the user is logged in."
+  desc "User management for HP-UX. This provider uses the undocumented `-F`
+    switch to HP-UX's special `usermod` binary to work around the fact that
+    its standard `usermod` cannot make changes while the user is logged in."
 
   defaultfor :operatingsystem => "hp-ux"
   confine :operatingsystem => "hp-ux"

data/lib/puppet/provider/user/ldap.rb

@@ -1,16 +1,16 @@
 require 'puppet/provider/ldap'
 
 Puppet::Type.type(:user).provide :ldap, :parent => Puppet::Provider::Ldap do
-  desc "User management via `ldap`.  This provider requires that you
-    have valid values for all of the ldap-related settings,
-    including `ldapbase`.  You will also almost definitely need settings
-    for `ldapuser` and `ldappassword`, so that your clients can write
-    to ldap.
+  desc "User management via LDAP.
+
+    This provider requires that you have valid values for all of the
+    LDAP-related settings in `puppet.conf`, including `ldapbase`.  You will
+    almost definitely need settings for `ldapuser` and `ldappassword` in order
+    for your clients to write to LDAP.
 
     Note that this provider will automatically generate a UID for you if
     you do not specify one, but it is a potentially expensive operation,
-    as it iterates across all existing users to pick the appropriate next
-    one."
+    as it iterates across all existing users to pick the appropriate next one."
 
   confine :feature => :ldap, :false => (Puppet[:ldapuser] == "")
 

data/lib/puppet/provider/user/user_role_add.rb

@@ -2,7 +2,7 @@ require 'puppet/util/user_attr'
 
 Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source => :useradd do
 
-  desc "User management inherits `useradd` and adds logic to manage roles on Solaris using roleadd."
+  desc "User and role management on Solaris, via `useradd` and `roleadd`."
 
   defaultfor :operatingsystem => :solaris
 
@@ -168,25 +168,29 @@ Puppet::Type.type(:user).provide :user_role_add, :parent => :useradd, :source =>
   #Smooth like 80 grit
   def password=(cryptopw)
     begin
-      File.open("/etc/shadow", "r") do |shadow|
-        File.open("/etc/shadow_tmp", "w", 0600) do |shadow_tmp|
+      File.open(shadow_file, "r") do |shadow|
+        File.open("#{shadow_file}_tmp", "w", 0600) do |shadow_tmp|
           while line = shadow.gets
             line_arr = line.split(':')
             if line_arr[0] == @resource[:name]
               line_arr[1] = cryptopw
+              line_arr[2] = Time.now().to_i / 86400
               line = line_arr.join(':')
             end
             shadow_tmp.print line
           end
         end
       end
-      File.rename("/etc/shadow_tmp", "/etc/shadow")
+      File.rename("#{shadow_file}_tmp", shadow_file)
     rescue => detail
       fail "Could not write temporary shadow file: #{detail}"
     ensure
       # Make sure this *always* gets deleted
-      File.unlink("/etc/shadow_tmp") if File.exist?("/etc/shadow_tmp")
+      File.unlink("#{shadow_file}_tmp") if File.exist?("#{shadow_file}_tmp")
     end
   end
-end
 
+  private
+
+  def shadow_file; '/etc/shadow'; end
+end

data/lib/puppet/provider/user/useradd.rb

@@ -1,7 +1,9 @@
 require 'puppet/provider/nameservice/objectadd'
 
 Puppet::Type.type(:user).provide :useradd, :parent => Puppet::Provider::NameService::ObjectAdd do
-  desc "User management via `useradd` and its ilk.  Note that you will need to install the `Shadow Password` Ruby library often known as ruby-libshadow to manage user passwords."
+  desc "User management via `useradd` and its ilk.  Note that you will need to
+    install Ruby's shadow password library (often known as `ruby-libshadow`)
+    if you wish to manage user passwords."
 
   commands :add => "useradd", :delete => "userdel", :modify => "usermod", :password => "chage"
 

data/lib/puppet/provider/user/windows_adsi.rb

@@ -1,11 +1,10 @@
 require 'puppet/util/adsi'
 
 Puppet::Type.type(:user).provide :windows_adsi do
-  desc "User management for Windows"
+  desc "User management for Windows."
 
   defaultfor :operatingsystem => :windows
-  confine :operatingsystem => :windows
-  confine :feature => :microsoft_windows
+  confine    :operatingsystem => :windows
 
   has_features :manages_homedir, :manages_passwords
 
@@ -23,6 +22,8 @@ Puppet::Type.type(:user).provide :windows_adsi do
 
   def create
     @user = Puppet::Util::ADSI::User.create(@resource[:name])
+    @user.commit
+
     [:comment, :home, :groups].each do |prop|
       send("#{prop}=", @resource[prop]) if @resource[prop]
     end

data/lib/puppet/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::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_color = r.key, r.value, r.color
+      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_color = l.key, l.value, l.color
+      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