fakes3 0.1.1 → 0.1.2

data/.gitignore

@@ -2,3 +2,4 @@ pkg/*
 *.gem
 .bundle
 tmp
+test_root

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fakes3 (0.1.0)
+    fakes3 (0.1.1)
       builder
       thor
 

data/README.md

@@ -12,9 +12,11 @@ FakeS3 doesn't support all of the S3 command set, but the basic ones like put, g
 list, copy, and make bucket are supported.  More coming soon.
 
 ## Installation
+
     gem install fakes3
 
 ## Running
+
 To run a fakes3 server, you just specify a root and a port.
 
     fakes3 -r /mnt/fakes3_root -p 4567
@@ -25,6 +27,8 @@ Take a look at the test cases to see client example usage.  For now, FakeS3 is
 mainly tested with s3cmd, aws-s3 gem, and right_aws.  There are plenty more
 libraries out there, and please do mention if other clients work or not.
 
+Here is a running list of [supported clients](https://github.com/jubos/fake-s3/wiki/Supported-Clients "Supported Clients")
+
 ## Running Tests
 
 Start the test server using
@@ -39,4 +43,4 @@ It is a TODO to get this to be just one command
 
 ## More Information
 
-Check out the wiki https://github.com/jubos/fake-s3/wiki
+Check out the [wiki](https://github.com/jubos/fake-s3/wiki)

data/fakes3.gemspec

@@ -18,9 +18,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency "aws-s3"
   s.add_development_dependency "right_aws"
   #s.add_development_dependency "aws-sdk"
-  #s.add_development_dependency "ruby-debug19"
+  s.add_development_dependency "ruby-debug19"
   s.add_dependency "thor"
   s.add_dependency "builder"
+  #s.add_dependency "algorithms"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/fakes3/bucket.rb

@@ -1,7 +1,7 @@
 require 'builder'
 require 'thread'
 require 'fakes3/s3_object'
-require 'fakes3/red_black_tree'
+require 'fakes3/sorted_object_list'
 
 module FakeS3
   class Bucket
@@ -10,27 +10,32 @@ module FakeS3
     def initialize(name,creation_date,objects)
       @name = name
       @creation_date = creation_date
-      @objects = SortedSet.new
-      @objects = RedBlackTree.new
+      @objects = SortedObjectList.new
       objects.each do |obj|
         @objects.add(obj)
       end
       @mutex = Mutex.new
     end
 
-    def <<(object)
-      # Unfortunately have to synchronize here since the RB Tree is not thread
-      # safe. Probably can get finer granularity if performance is important
+    def find(object_name)
       @mutex.synchronize do
-        exists = @objects.search(object.name)
-        if exists.nil?
-          @objects.add(object.name,object)
-        end
+        @objects.find(object_name)
       end
     end
 
-    def delete(object_name)
-      @objects.delete_via_key(object_name)
+    def add(object)
+      # Unfortunately have to synchronize here since the our SortedObjectList
+      # not thread safe. Probably can get finer granularity if performance is
+      # important
+      @mutex.synchronize do
+        @objects.add(object)
+      end
+    end
+
+    def remove(object)
+      @mutex.synchronize do
+        @objects.remove(object)
+      end
     end
 
     def query_for_range(options)
@@ -39,12 +44,9 @@ module FakeS3
       max_keys = options[:max_keys] || 1000
       delimiter = options[:delimiter]
 
-      matches = []
-      is_truncated = false
-
+      match_set = nil
       @mutex.synchronize do
-        matches, is_truncated = @objects.search_for_range(
-          marker,prefix,max_keys,delimiter)
+        match_set = @objects.list(options)
       end
 
       bq = BucketQuery.new
@@ -53,8 +55,8 @@ module FakeS3
       bq.prefix = prefix
       bq.max_keys = max_keys
       bq.delimiter = delimiter
-      bq.matches = matches
-      bq.is_truncated = is_truncated
+      bq.matches = match_set.matches
+      bq.is_truncated = match_set.is_truncated
       return bq
     end
 

data/lib/fakes3/cli.rb

@@ -15,6 +15,7 @@ module FakeS3
       store = nil
       if options[:root]
         root = File.expand_path(options[:root])
+        # TODO Do some sanity checking here
         store = FileStore.new(root)
       end
 

data/lib/fakes3/errors.rb

@@ -0,0 +1,46 @@
+module FakeS3
+  class FakeS3Exception < RuntimeError
+    attr_accessor :resource,:request_id
+
+    def self.metaclass; class << self; self; end; end
+
+    def self.traits(*arr)
+      return @traits if arr.empty?
+      attr_accessor *arr
+
+      arr.each do |a|
+        metaclass.instance_eval do
+          define_method( a ) do |val|
+            @traits ||= {}
+            @traits[a] = val
+          end
+        end
+      end
+
+      class_eval do
+        define_method( :initialize ) do
+          self.class.traits.each do |k,v|
+            instance_variable_set("@#{k}", v)
+          end
+        end
+      end
+    end
+
+    traits :message,:http_status
+
+    def code
+      self.class.to_s
+    end
+  end
+
+  class NoSuchBucket < FakeS3Exception
+    message "The bucket you tried to delete is not empty."
+    http_status "404"
+  end
+
+  class BucketNotEmpty < FakeS3Exception
+    message "The bucket you tried to delete is not empty."
+    http_status "409"
+  end
+
+end

data/lib/fakes3/file_store.rb

@@ -45,6 +45,10 @@ module FakeS3
       @buckets
     end
 
+    def get_bucket_folder(bucket)
+      File.join(@root,bucket.name)
+    end
+
     def get_bucket(bucket)
       @bucket_hash[bucket]
     end
@@ -58,12 +62,20 @@ module FakeS3
       end
     end
 
-    def get_object(bucket,object, request)
+    def delete_bucket(bucket_name)
+      bucket = get_bucket(bucket_name)
+      raise NoSuchBucket if !bucket
+      raise BucketNotEmpty if bucket.objects.count > 0
+      FileUtils.rm_r(get_bucket_folder(bucket))
+      @bucket_hash.delete(bucket_name)
+    end
+
+    def get_object(bucket,object_name, request)
       begin
         real_obj = S3Object.new
-        obj_root = File.join(@root,bucket,object,SHUCK_METADATA_DIR)
+        obj_root = File.join(@root,bucket,object_name,SHUCK_METADATA_DIR)
         metadata = YAML.parse(File.open(File.join(obj_root,"metadata"),'rb').read)
-        real_obj.name = object
+        real_obj.name = object_name
         real_obj.md5 = metadata[:md5].value
         real_obj.content_type = metadata[:content_type] ? metadata[:content_type].value : "application/octet-stream"
         #real_obj.io = File.open(File.join(obj_root,"content"),'rb')
@@ -78,14 +90,13 @@ module FakeS3
     def object_metadata(bucket,object)
     end
 
-    def copy_object(src_bucket,src_object,dst_bucket,dst_object)
-      src_root = File.join(@root,src_bucket,src_object,SHUCK_METADATA_DIR)
-      src_obj = S3Object.new
+    def copy_object(src_bucket_name,src_name,dst_bucket_name,dst_name)
+      src_root = File.join(@root,src_bucket_name,src_name,SHUCK_METADATA_DIR)
       src_metadata_filename = File.join(src_root,"metadata")
       src_metadata = YAML.parse(File.open(src_metadata_filename,'rb').read)
       src_content_filename = File.join(src_root,"content")
 
-      dst_filename= File.join(@root,dst_bucket,dst_object)
+      dst_filename= File.join(@root,dst_bucket_name,dst_name)
       FileUtils.mkdir_p(dst_filename)
 
       metadata_dir = File.join(dst_filename,SHUCK_METADATA_DIR)
@@ -106,9 +117,17 @@ module FakeS3
         end
       end
 
+      src_bucket = self.get_bucket(src_bucket_name)
+      dst_bucket = self.get_bucket(dst_bucket_name)
+
       obj = S3Object.new
+      obj.name = dst_name
       obj.md5 = src_metadata[:md5]
       obj.content_type = src_metadata[:content_type]
+
+      src_obj = src_bucket.find(src_name)
+      dst_bucket.add(obj)
+      src_bucket.remove(src_obj)
       return obj
     end
 
@@ -146,8 +165,7 @@ module FakeS3
         obj.md5 = metadata_struct[:md5]
         obj.content_type = metadata_struct[:content_type]
 
-        # TODO need a semaphore here since bucket is not probably not thread safe
-        bucket << obj
+        bucket.add(obj)
         return obj
       rescue
         puts $!
@@ -160,7 +178,8 @@ module FakeS3
       begin
         filename = File.join(@root,bucket.name,object_name)
         FileUtils.rm_rf(filename)
-        bucket.delete(object_name)
+        object = bucket.find(object_name)
+        bucket.remove(object)
       rescue
         puts $!
         $!.backtrace.each { |line| puts line }

data/lib/fakes3/s3_object.rb

@@ -3,6 +3,14 @@ module FakeS3
     include Comparable
     attr_accessor :name,:size,:creation_date,:md5,:io,:content_type
 
+    def hash
+      @name.hash
+    end
+
+    def eql?(object)
+      @name == object.name
+    end
+
     # Sort by the object's name
     def <=>(object)
       @name <=> object.name

data/lib/fakes3/server.rb

@@ -3,6 +3,7 @@ require 'fakes3/file_store'
 require 'fakes3/xml_adapter'
 require 'fakes3/bucket_query'
 require 'fakes3/unsupported_operation'
+require 'fakes3/errors'
 
 module FakeS3
   class Request
@@ -139,8 +140,8 @@ module FakeS3
       response['Content-Type'] = "text/xml"
     end
 
+    # Posts aren't supported yet
     def do_POST(request,response)
-      p request
     end
 
     def do_DELETE(request,response)
@@ -150,6 +151,8 @@ module FakeS3
       when Request::DELETE_OBJECT
         bucket_obj = @store.get_bucket(s_req.bucket)
         @store.delete_object(bucket_obj,s_req.object,s_req.webrick_request)
+      when Request::DELETE_BUCKET
+        @store.delete_bucket(s_req.bucket)
       end
 
       response.status = 204

data/lib/fakes3/sorted_object_list.rb

@@ -0,0 +1,100 @@
+require 'set'
+module FakeS3
+  class S3MatchSet
+    attr_accessor :matches,:is_truncated
+    def initialize
+      @matches = []
+      @is_truncated = false
+    end
+  end
+
+  # This class has some of the semantics necessary for how buckets can return
+  # their items
+  #
+  # It is currently implemented naively as a sorted set + hash If you are going
+  # to try to put massive lists inside buckets and ls them, you will be sorely
+  # disappointed about this performance.
+  class SortedObjectList
+
+    def initialize
+      @sorted_set = SortedSet.new
+      @object_map = {}
+      @mutex = Mutex.new
+    end
+
+    def count
+      @sorted_set.count
+    end
+
+    def find(object_name)
+      @object_map[object_name]
+    end
+
+    # Add an S3 object into the sorted list
+    def add(s3_object)
+      return if !s3_object
+
+      @object_map[s3_object.name] = s3_object
+      @sorted_set << s3_object
+    end
+
+    def remove(s3_object)
+      return if !s3_object
+
+      @object_map.delete(s3_object.name)
+      @sorted_set.delete(s3_object)
+    end
+
+    # Return back a set of matches based on the passed in options
+    #
+    # options:
+    #
+    # :marker : a string to start the lexographical search (it is not included
+    #           in the result)
+    # :max_keys  : a maximum number of results
+    # :prefix    : a string to filter the results by
+    # :delimiter : not supported yet
+    def list(options)
+      marker = options[:marker]
+      prefix = options[:prefix]
+      max_keys = options[:max_keys] || 1000
+      delimiter = options[:delimiter]
+
+      ms = S3MatchSet.new
+
+      marker_found = true
+      pseudo = nil
+      if marker
+        marker_found = false
+        if !@object_map[marker]
+          pseudo = S3Object.new
+          pseudo.name = marker
+          @sorted_set << pseudo
+        end
+      end
+
+      count = 0
+      @sorted_set.each do |s3_object|
+        if marker_found && (!prefix or s3_object.name.index(prefix) == 0)
+          count += 1
+          if count <= max_keys
+            ms.matches << s3_object
+          else
+            is_truncated = true
+            break
+          end
+        end
+
+        if marker and marker == s3_object.name
+          marker_found = true
+        end
+      end
+
+      if pseudo
+        @sorted_set.delete(pseudo)
+      end
+
+      return ms
+    end
+  end
+end

data/lib/fakes3/version.rb

@@ -1,3 +1,3 @@
 module FakeS3
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/fakes3/xml_adapter.rb

@@ -24,6 +24,19 @@ module FakeS3
       output
     end
 
+    def self.error(error)
+      output = ""
+      xml = Builder::XmlMarkup.new(:target => output)
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.Error { |err|
+        err.Code(error.code)
+        err.Message(error.message)
+        err.Resource(error.resource)
+        err.RequestId(1)
+      }
+      output
+    end
+
     # <?xml version="1.0" encoding="UTF-8"?>
     #<Error>
     #  <Code>NoSuchKey</Code>
@@ -45,6 +58,19 @@ module FakeS3
       output
     end
 
+    def self.error_bucket_not_empty(name)
+      output = ""
+      xml = Builder::XmlMarkup.new(:target => output)
+      xml.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
+      xml.Error { |err|
+        err.Code("BucketNotEmpty")
+        err.Message("The bucket you tried to delete is not empty.")
+        err.Resource(name)
+        err.RequestId(1)
+      }
+      output
+    end
+
     def self.error_no_such_key(name)
       output = ""
       xml = Builder::XmlMarkup.new(:target => output)
@@ -89,6 +115,12 @@ module FakeS3
     def self.append_objects_to_list_bucket_result(lbr,objects)
       return if objects.nil? or objects.size == 0
 
+      if objects.index(nil)
+        require 'ruby-debug'
+        Debugger.start
+        debugger
+      end
+
       objects.each do |s3_object|
         lbr.Contents { |contents|
           contents.Key(s3_object.name)

data/test/right_aws_commands_test.rb

@@ -1,6 +1,6 @@
 require 'test/test_helper'
 require 'fileutils'
-require 'fakes3/server'
+#require 'fakes3/server'
 require 'right_aws'
 
 class RightAWSCommandsTest < Test::Unit::TestCase

data/test/s3_commands_test.rb

@@ -1,13 +1,16 @@
 require 'test/test_helper'
 require 'fileutils'
-require 'fakes3/server'
+#require 'fakes3/server'
 require 'aws/s3'
 
 class S3CommandsTest < Test::Unit::TestCase
   include AWS::S3
 
   def setup
-    AWS::S3::Base.establish_connection!(:access_key_id => "123", :secret_access_key => "abc", :server => "localhost", :port => "10453" )
+    AWS::S3::Base.establish_connection!(:access_key_id => "123",
+                                        :secret_access_key => "abc",
+                                        :server => "localhost",
+                                        :port => "10453" )
   end
 
   def teardown
@@ -17,6 +20,23 @@ class S3CommandsTest < Test::Unit::TestCase
   def test_create_bucket
     bucket = Bucket.create("ruby_aws_s3")
     assert_not_nil bucket
+
+    bucket_names = []
+    Service.buckets.each do |bucket|
+      bucket_names << bucket.name
+    end
+    assert(bucket_names.index("ruby_aws_s3") >= 0)
+  end
+
+  def test_destroy_bucket
+    Bucket.create("deletebucket")
+    Bucket.delete("deletebucket")
+
+    begin
+      bucket = Bucket.find("deletebucket")
+      assert_fail("Shouldn't succeed here")
+    rescue
+    end
   end
 
   def test_store
@@ -102,11 +122,29 @@ class S3CommandsTest < Test::Unit::TestCase
     S3Object.store("something_to_delete","asdf","ruby_aws_s3")
     something = S3Object.find("something_to_delete","ruby_aws_s3")
     S3Object.delete("something_to_delete","ruby_aws_s3")
+
+    assert_raise AWS::S3::NoSuchKey do
+      should_throw = S3Object.find("something_to_delete","find_bucket")
+    end
+  end
+
+  def test_rename
+    bucket = Bucket.create("ruby_aws_s3")
+    S3Object.store("something_to_rename","asdf","ruby_aws_s3")
+    S3Object.rename("something_to_rename","renamed","ruby_aws_s3")
+
+    renamed = S3Object.find("renamed","ruby_aws_s3")
+    assert_not_nil(renamed)
+    assert_equal(renamed.value,'asdf')
+
+    assert_raise AWS::S3::NoSuchKey do
+      should_throw = S3Object.find("something_to_rename","ruby_aws_s3")
+    end
   end
 
   def test_larger_lists
     Bucket.create("ruby_aws_s3_many")
-    (0..100).each do |i|
+    (0..50).each do |i|
       ('a'..'z').each do |letter|
         name = "#{letter}#{i}"
         S3Object.store(name,"asdf","ruby_aws_s3_many")
@@ -114,10 +152,11 @@ class S3CommandsTest < Test::Unit::TestCase
     end
 
     bucket = Bucket.find("ruby_aws_s3_many")
-    assert_equal(bucket.objects.first.key,"a0")
     assert_equal(bucket.size,1000)
+    assert_equal(bucket.objects.first.key,"a0")
   end
 
+
   # Copying an object
   #S3Object.copy 'headshot.jpg', 'headshot2.jpg', 'photos'
 

data/test/s3cmd_test.rb

@@ -1,8 +1,9 @@
 require 'test/test_helper'
 require 'fileutils'
-require 'fakes3/server'
 
 # You need to have s3cmd installed to use this
+# Also, s3cmd doesn't support path style requests, so in order to properly test
+# it you need to modify your dns by changing /etc/hosts or using dnsmasq
 class S3CmdTest < Test::Unit::TestCase
 
   def setup

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Curtis Spencer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-16 00:00:00 -06:00
+date: 2012-04-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -59,7 +59,7 @@ dependencies:
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: thor
+  name: ruby-debug19
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
@@ -69,10 +69,10 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :runtime
+  type: :development
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  name: builder
+  name: thor
   prerelease: false
   requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
@@ -84,6 +84,19 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id006
 description: Use FakeS3 to test basic S3 functionality without actually connecting to S3
 email: 
 - thorin@gmail.com
@@ -105,11 +118,12 @@ files:
 - lib/fakes3/bucket.rb
 - lib/fakes3/bucket_query.rb
 - lib/fakes3/cli.rb
+- lib/fakes3/errors.rb
 - lib/fakes3/file_store.rb
 - lib/fakes3/rate_limitable_file.rb
-- lib/fakes3/red_black_tree.rb
 - lib/fakes3/s3_object.rb
 - lib/fakes3/server.rb
+- lib/fakes3/sorted_object_list.rb
 - lib/fakes3/unsupported_operation.rb
 - lib/fakes3/version.rb
 - lib/fakes3/xml_adapter.rb

data/lib/fakes3/red_black_tree.rb

@@ -1,395 +0,0 @@
-# Algorithm based on "Introduction to Algorithms" by Cormen and others
-# Retrieved from
-# https://github.com/headius/redblack/blob/master/red_black_tree.rb
-#
-# Modified by Curtis Spencer
-class RedBlackTree
-  class Node
-    attr_accessor :color
-    attr_accessor :key
-    attr_accessor :left
-    attr_accessor :right
-    attr_accessor :parent
-    attr_accessor :value
-
-    RED = :red
-    BLACK = :black
-    COLORS = [RED, BLACK].freeze
-
-    def initialize(key, value, color = RED)
-      raise ArgumentError, "Bad value for color parameter" unless COLORS.include?(color)
-      @color = color
-      @key = key
-      @value = value
-      @left = @right = @parent = NilNode.instance
-    end
-
-    def black?
-      return color == BLACK
-    end
-
-    def red?
-      return color == RED
-    end
-  end
-
-  class NilNode < Node
-    class << self
-      private :new
-      @instance = nil
-
-      # it's not thread safe
-      def instance
-        if @instance.nil?
-          @instance = new
-
-          def instance
-            return @instance
-          end
-        end
-
-        return @instance
-      end
-    end
-
-    def initialize
-      self.color = BLACK
-      self.key = 0
-      self.left = nil
-      self.right = nil
-      self.parent = nil
-    end
-
-    def nil?
-      return true
-    end
-  end
-
-  include Enumerable
-
-  attr_accessor :root
-  attr_accessor :size
-
-  def initialize
-    self.root = NilNode.instance
-    self.size = 0
-  end
-
-  def add(key,value)
-    insert(Node.new(key,value))
-  end
-
-  def insert(x)
-    insert_helper(x)
-
-    x.color = Node::RED
-    while x != root && x.parent.color == Node::RED
-      if x.parent == x.parent.parent.left
-        y = x.parent.parent.right
-        if !y.nil? && y.color == Node::RED
-          x.parent.color = Node::BLACK
-          y.color = Node::BLACK
-          x.parent.parent.color = Node::RED
-          x = x.parent.parent
-        else
-          if x == x.parent.right
-            x = x.parent
-            left_rotate(x)
-          end
-          x.parent.color = Node::BLACK
-          x.parent.parent.color = Node::RED
-          right_rotate(x.parent.parent)
-        end
-      else
-        y = x.parent.parent.left
-        if !y.nil? && y.color == Node::RED
-          x.parent.color = Node::BLACK
-          y.color = Node::BLACK
-          x.parent.parent.color = Node::RED
-          x = x.parent.parent
-        else
-          if x == x.parent.left
-            x = x.parent
-            right_rotate(x)
-          end
-          x.parent.color = Node::BLACK
-          x.parent.parent.color = Node::RED
-          left_rotate(x.parent.parent)
-        end
-      end
-    end
-    root.color = Node::BLACK
-  end
-
-  alias << insert
-
-  def delete(z)
-    y = (z.left.nil? || z.right.nil?) ? z : successor(z)
-    x = y.left.nil? ? y.right : y.left
-    x.parent = y.parent
-
-    if y.parent.nil?
-      self.root = x
-    else
-      if y == y.parent.left
-        y.parent.left = x
-      else
-        y.parent.right = x
-      end
-    end
-
-    z.key = y.key if y != z
-
-    if y.color == Node::BLACK
-      delete_fixup(x)
-    end
-
-    self.size -= 1
-    return y
-  end
-
-  def minimum(x = root)
-    while !x.left.nil?
-      x = x.left
-    end
-    return x
-  end
-
-  def maximum(x = root)
-    while !x.right.nil?
-      x = x.right
-    end
-    return x
-  end
-
-  def successor(x)
-    if !x.right.nil?
-      return minimum(x.right)
-    end
-    y = x.parent
-    while !y.nil? && x == y.right
-      x = y
-      y = y.parent
-    end
-    return y
-  end
-
-  def predecessor(x)
-    if !x.left.nil?
-      return maximum(x.left)
-    end
-    y = x.parent
-    while !y.nil? && x == y.left
-      x = y
-      y = y.parent
-    end
-    return y
-  end
-
-  def inorder_walk(x = root)
-    x = self.minimum
-    while !x.nil?
-      yield x.key
-      x = successor(x)
-    end
-  end
-
-  alias each inorder_walk
-
-  def reverse_inorder_walk(x = root)
-    x = self.maximum
-    while !x.nil?
-      yield x.key
-      x = predecessor(x)
-    end
-  end
-
-  alias reverse_each reverse_inorder_walk
-
-  def search(key, x = root)
-    while !x.nil? && x.key != key
-      key < x.key ? x = x.left : x = x.right
-    end
-    return x
-  end
-
-  # Search for a successor even if the key doesn't exist
-  def search_for_possible_successor(key, x = root)
-    node = search(key)
-    pseudo = false
-    if node.class == NilNode
-      insert(Node.new(key,nil))
-      node = search(key)
-      pseudo = true
-    end
-
-    succ = successor(node)
-    delete(node) if pseudo
-    return nil if !succ
-    return succ
-  end
-
-  def delete_via_key(key)
-    node = search(key)
-    return if node.class == NilNode
-    delete(node)
-  end
-
-  # Return array of matches and a boolean to denote whether truncation occurred
-  def search_for_range(marker,prefix,max_keys,delimiter)
-    succ = nil
-    if marker
-      succ = search_for_possible_successor(marker)
-    else
-      succ = self.minimum
-    end
-
-    return [],false if succ.class == NilNode
-
-    keys_count = 0
-    keys = []
-    is_truncated = false
-
-    loop do
-      if !prefix or succ.key.index(prefix) == 0
-        keys_count += 1
-        if keys_count <= max_keys
-          keys << succ.value
-        else
-          is_truncated = true
-          break
-        end
-      end
-      succ = successor(succ)
-      if succ.class == NilNode
-        break
-      end
-    end
-
-    return keys,is_truncated
-  end
-
-  def empty?
-    return self.root.nil?
-  end
-
-  def black_height(x = root)
-    height = 0
-    while !x.nil?
-      x = x.left
-      height +=1 if x.nil? || x.black?
-    end
-    return height
-  end
-
-private
-
-  def left_rotate(x)
-    raise "x.right is nil!" if x.right.nil?
-    y = x.right
-    x.right = y.left
-    y.left.parent = x if !y.left.nil?
-    y.parent = x.parent
-    if x.parent.nil?
-      self.root = y
-    else
-      if x == x.parent.left
-        x.parent.left = y
-      else
-        x.parent.right = y
-      end
-    end
-    y.left = x
-    x.parent = y
-  end
-
-  def right_rotate(x)
-    raise "x.left is nil!" if x.left.nil?
-    y = x.left
-    x.left = y.right
-    y.right.parent = x if !y.right.nil?
-    y.parent = x.parent
-    if x.parent.nil?
-      self.root = y
-    else
-      if x == x.parent.left
-        x.parent.left = y
-      else
-        x.parent.right = y
-      end
-    end
-    y.right = x
-    x.parent = y
-  end
-
-  def insert_helper(z)
-    y = NilNode.instance
-    x = root
-    while !x.nil?
-      y = x
-      z.key < x.key ? x = x.left : x = x.right
-    end
-    z.parent = y
-    if y.nil?
-      self.root = z
-    else
-      z.key < y.key ? y.left = z : y.right = z
-    end
-    self.size += 1
-  end
-
-  def delete_fixup(x)
-    while x != root && x.color == Node::BLACK
-      if x == x.parent.left
-        w = x.parent.right
-        if w.color == Node::RED
-          w.color = Node::BLACK
-          x.parent.color = Node::RED
-          left_rotate(x.parent)
-          w = x.parent.right
-        end
-        if w.left.color == Node::BLACK && w.right.color == Node::BLACK
-          w.color = Node::RED
-          x = x.parent
-        else
-          if w.right.color == Node::BLACK
-            w.left.color = Node::BLACK
-            w.color = Node::RED
-            right_rotate(w)
-            w = x.parent.right
-          end
-          w.color = x.parent.color
-          x.parent.color = Node::BLACK
-          w.right.color = Node::BLACK
-          left_rotate(x.parent)
-          x = root
-        end
-      else
-        w = x.parent.left
-        if w.color == Node::RED
-          w.color = Node::BLACK
-          x.parent.color = Node::RED
-          right_rotate(x.parent)
-          w = x.parent.left
-        end
-        if w.right.color == Node::BLACK && w.left.color == Node::BLACK
-          w.color = Node::RED
-          x = x.parent
-        else
-          if w.left.color == Node::BLACK
-            w.right.color = Node::BLACK
-            w.color = Node::RED
-            left_rotate(w)
-            w = x.parent.left
-          end
-          w.color = x.parent.color
-          x.parent.color = Node::BLACK
-          w.left.color = Node::BLACK
-          right_rotate(x.parent)
-          x = root
-        end
-      end
-    end
-    x.color = Node::BLACK
-  end
-end