itree 0.1.0

data/lib/itree.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__),"itree","**","*.rb")].each do |file|
+	require file
+end

data/lib/itree/node.rb

@@ -0,0 +1,65 @@
+module Intervals
+	class Node
+		attr_accessor :data, :scores, :subLeftMax, :subRightMax, :balance, :left, :right, :parent
+
+		def initialize(min,max,data)
+			raise ArgumentError.new("first agument cannot be greater than second argument") if min > max
+			@scores = [min,max]
+			@subLeftMax = nil
+			@subRightMax = nil
+			@balance = 0
+			@data = data
+		end
+
+		def <=>(other)
+			if @scores[0] != other.scores[0]
+				@scores[0] <=> other.scores[0]
+			else
+				other.scores[1] <=> @scores[1]
+			end
+		end
+
+		def ==(other)
+			@scores == other.scores
+		end
+
+		def resetBalance
+			case @balance
+			when -1
+				@left.balance = 0
+				@right.balance = 1
+			when 0
+				@left.balance = 0
+				@right.balance = 0
+			when 1
+				@left.balance = -1
+				@right.balance = 0
+			end
+			@balance = 0
+		end
+
+		def updateMaxScores
+			oldNodeMax = 0
+			locNode = self
+			while locNode
+				if locNode.left
+					oldNodeMax = locNode.left.scores[1]
+					oldNodeMax = (locNode.left.subLeftMax && (oldNodeMax < locNode.left.subLeftMax)) ? locNode.left.subLeftMax : oldNodeMax
+					oldNodeMax = (locNode.left.subRightMax && (oldNodeMax < locNode.left.subRightMax)) ? locNode.left.subRightMax : oldNodeMax
+					locNode.subLeftMax = oldNodeMax
+				else
+					locNode.subLeftMax = nil
+				end
+				if locNode.right
+					oldNodeMax = locNode.right.scores[1]
+					oldNodeMax = (locNode.right.subLeftMax && (oldNodeMax < locNode.right.subLeftMax)) ? locNode.right.subLeftMax : oldNodeMax
+					oldNodeMax = (locNode.right.subRightMax && (oldNodeMax < locNode.right.subRightMax)) ? locNode.right.subRightMax : oldNodeMax
+					locNode.subRightMax = oldNodeMax
+				else
+					locNode.subRightMax = nil
+				end
+				locNode = locNode.parent
+			end
+		end
+	end
+end

data/lib/itree/tree.rb

@@ -0,0 +1,389 @@
+module Intervals
+	class Tree
+		attr_accessor :root, :size
+
+		def initialize
+			@root = nil
+			@size = 0
+		end
+
+		def insert(leftScore, rightScore, data=nil, updateData=false)
+			node = Node.new(leftScore,rightScore,data)
+			success = true
+
+			if @root.nil?
+				@root = node
+			else
+				balance,success = insertNode(@root,node,updateData)
+			end
+
+			@size = @size + 1 if success
+			return success
+		end
+
+		def insert!(leftScore, rightScore, data=nil)
+			return insert(leftScore,rightScore,data,true)
+		end
+
+		def stab(minScore,maxScore=nil)
+			maxScore = minScore if maxScore.nil?
+			results = []
+			stabNode(@root,minScore,maxScore,results) if @root
+			results
+		end
+
+		def remove(leftScore, rightScore)
+			if @root
+				delNode = Node.new(leftScore,rightScore,nil)
+				height,removed = removeNode(@root,delNode)
+				if removed
+					@size = @size - 1
+					@root = nil if @size == 0
+					return true
+				end
+			end
+			return false
+		end
+
+		private
+		def insertNode(locNode,insertNode,updateData=false)
+			diff = locNode <=> insertNode
+
+			if diff > 0
+				if locNode.left.nil?
+					locNode.left = insertNode
+					insertNode.parent = locNode
+					locNode.balance = locNode.balance - 1
+					locNode.updateMaxScores
+					if locNode.balance == 0
+						return 0,true
+					else
+						return 1,true
+					end
+				else
+					balanceUpdate,success = insertNode(locNode.left,insertNode,updateData)
+					if balanceUpdate != 0
+						locNode.balance = locNode.balance - 1
+						if locNode.balance == 0
+							return 0,success
+						elsif locNode.balance == -1
+							return 1,success
+						end
+
+						if locNode.left.balance < 0
+							rightRotation(locNode)
+							locNode.balance = 0
+							locNode.parent.balance = 0
+							locNode.subLeftMax = locNode.parent.subRightMax
+							locNode.parent.subRightMax = -Float::INFINITY
+						else
+							leftRotation(locNode.left)
+							rightRotation(locNode)
+							locNode.parent.resetBalance
+
+							locNode.subLeftMax = locNode.parent.subRightMax
+							locNode.parent.left.subRightMax = locNode.parent.subLeftMax
+							locNode.parent.subRightMax = -Float::INFINITY
+							locNode.parent.subLeftMax = -Float::INFINITY
+						end
+
+						locNode.parent.updateMaxScores
+					end
+					return 0,success
+				end
+			elsif diff < 0
+				if locNode.right.nil?
+					locNode.right = insertNode
+					insertNode.parent = locNode
+					locNode.balance = locNode.balance + 1
+					locNode.updateMaxScores
+					if locNode.balance == 0
+						return 0,true
+					else
+						return 1,true
+					end
+				else
+					balanceUpdate,success = insertNode(locNode.right,insertNode,updateData)
+					if balanceUpdate != 0
+						locNode.balance = locNode.balance + 1
+						if locNode.balance == 0
+							return 0,success
+						elsif locNode.balance == 1
+							return 1,success
+						end
+
+						if locNode.right.balance > 0
+							leftRotation(locNode)
+							locNode.balance = 0
+							locNode.parent.balance = 0
+							locNode.subRightMax = locNode.parent.subLeftMax
+							locNode.parent.subLeftMax = -Float::INFINITY
+						else
+							rightRotation(locNode.right)
+							leftRotation(locNode)
+							locNode.parent.resetBalance
+
+							locNode.subRightMax = locNode.parent.subLeftMax
+							locNode.parent.right.subLeftMax = locNode.parent.subRightMax
+							locNode.parent.subRightMax = -Float::INFINITY
+							locNode.parent.subLeftMax = -Float::INFINITY
+						end
+
+						locNode.parent.updateMaxScores
+					end
+					return 0,success
+				end
+			else
+				locNode.data = insertNode.data if updateData
+				return 0,false
+			end
+		end
+
+		def removeFromParent(locNode,replacementNode)
+			if locNode.parent
+				if locNode.parent.left == locNode
+					locNode.parent.left = replacementNode
+				else
+					locNode.parent.right = replacementNode
+				end
+			else
+				@root = replacementNode
+			end
+		end
+
+		def removeNode(locNode, delNode)
+			diff = locNode <=> delNode
+			heightDelta = 0
+			replacementNode = nil
+			removed = false
+
+			if diff == 0
+				if locNode.left.nil?
+					if locNode.right.nil?
+						removeFromParent(locNode,nil)
+						locNode.parent.updateMaxScores if locNode.parent
+						removed = true
+						return -1,removed
+					end
+					removeFromParent(locNode,locNode.right)
+					locNode.right.parent = locNode.parent
+					locNode.parent.updateMaxScores if locNode.parent
+					locNode.right = nil
+					removed = true
+					return -1,removed
+				end
+
+				if locNode.right.nil?
+					removeFromParent(locNode,locNode.left)
+					locNode.left.parent = locNode.parent
+					locNode.parent.updateMaxScores if locNode.parent
+					locNode.left = nil
+					removed = true
+					return -1,removed
+				end
+
+				if locNode.balance < 0
+					replacementNode = locNode.left
+					while replacementNode.right do
+						replacementNode = replacementNode.right
+					end
+				else
+					replacementNode = locNode.right
+					while replacementNode.left do
+						replacementNode = replacementNode.left
+					end
+				end
+
+				heightDelta,removed = removeNode(locNode,replacementNode)
+
+				locNode.right.parent = replacementNode if locNode.right
+				locNode.left.parent = replacementNode if locNode.left
+
+				replacementNode.left = locNode.left
+				replacementNode.right = locNode.right
+				replacementNode.parent = locNode.parent
+				replacementNode.balance = locNode.balance
+
+				if locNode == @root
+					@root = replacementNode
+					replacementNode.updateMaxScores
+				else
+					if locNode == locNode.parent.left
+						locNode.parent.left = replacementNode
+					else
+						locNode.parent.right = replacementNode
+					end
+					replacementNode.updateMaxScores
+				end
+
+				locNode.left = nil
+				locNode.right = nil
+
+				if replacementNode.balance == 0
+					return heightDelta,removed
+				end
+				removed = true
+				return 0,removed
+			elsif diff > 0
+				if locNode.left
+					heightDelta,removed = removeNode(locNode.left,delNode)
+					if heightDelta
+						locNode.balance = locNode.balance + 1
+						if locNode.balance == 0
+							return -1,removed
+						elsif locNode.balance == 1
+							return 0,removed
+						end
+
+						if locNode.right.balance == 1
+							leftRotation(locNode)
+							locNode.parent.balance = 0
+							locNode.parent.left.balance = 0
+
+							locNode.subRightMax = locNode.parent.subLeftMax
+							locNode.parent.subLeftMax = nil
+							locNode.parent.updateMaxScores
+
+							return -1,removed
+						elsif locNode.right.balance == 0
+							leftRotation(locNode)
+							locNode.parent.balance = -1
+							locNode.parent.left.balance = 1
+
+							locNode.subRightMax = locNode.parent.subLeftMax
+							locNode.parent.subLeftMax = nil
+							locNode.parent.updateMaxScores
+
+							return 0,removed
+						end
+						rightRotation(locNode.right)
+						leftRotation(locNode)
+						locNode.parent.resetBalance
+
+						locNode.subRightMax = locNode.parent.subLeftMax
+						locNode.parent.right.subLeftMax = locNode.parent.subRightMax
+
+						locNode.parent.subRightMax = nil
+						locNode.parent.subLeftMax = nil
+						locNode.parent.updateMaxScores
+
+						return -1,removed
+					end
+				end
+			elsif diff < 0
+				if locNode.right
+					heightDelta,removed = removeNode(locNode.right,delNode)
+					if heightDelta
+						locNode.balance = locNode.balance - 1
+						if locNode.balance == 0
+							return 1,removed
+						elsif locNode.balance == -1
+							return 0,removed
+						end
+
+						if locNode.left.balance == -1
+							rightRotation(locNode)
+							locNode.parent.balance = 0
+							locNode.parent.right.balance = 0
+
+							locNode.subLeftMax = locNode.parent.subRightMax
+							locNode.parent.subRightMax = nil
+							locNode.parent.updateMaxScores
+
+							return -1,removed
+						elsif locNode.left.balance == 0
+							rightRotation(locNode)
+							locNode.parent.balance = 1
+							locNode.parent.right.balance = -1
+
+							locNode.subLeftMax = locNode.parent.subRightMax
+							locNode.parent.subRightMax = nil
+							locNode.parent.updateMaxScores
+
+							return 0,removed
+						end
+						leftRotation(locNode.left)
+						rightRotation(locNode)
+						locNode.parent.resetBalance
+
+						locNode.subLeftMax = locNode.parent.subRightMax
+						locNode.parent.left.subRightMax = locNode.parent.subLeftMax
+
+						locNode.parent.subLeftMax = nil
+						locNode.parent.subRightMax = nil
+						locNode.parent.updateMaxScores
+
+						return -1,removed
+					end
+				end
+			end
+
+			return 0,removed
+		end
+
+		def leftRotation(locNode)
+			newRoot = locNode.right
+			locNode.right = newRoot.left
+			if locNode.right
+				locNode.right.parent = locNode
+			end
+			newRoot.left = locNode
+
+			newRoot.parent = locNode.parent
+			locNode.parent = newRoot
+			if newRoot.parent
+				if ((newRoot.parent <=> newRoot) > -1)
+					newRoot.parent.left = newRoot
+				else
+					newRoot.parent.right = newRoot
+				end
+			else
+				@root = newRoot
+			end
+		end
+
+		def rightRotation(locNode)
+			newRoot = locNode.left
+			locNode.left = newRoot.right
+			if locNode.left
+				locNode.left.parent = locNode
+			end
+			newRoot.right = locNode
+
+			newRoot.parent = locNode.parent
+			locNode.parent = newRoot
+			if newRoot.parent
+				if ((newRoot.parent <=> newRoot) > -1)
+					newRoot.parent.left = newRoot
+				else
+					newRoot.parent.right = newRoot
+				end
+			else
+				@root = newRoot
+			end
+		end
+
+		def stabNode(node, minScore, maxScore, results)
+			if node.subRightMax &&
+				 minScore > node.subRightMax &&
+				 node.subLeftMax &&
+				 minScore > node.subLeftMax &&
+				 minScore > node.scores[1]
+				return
+			end
+			if node.left
+				stabNode(node.left, minScore, maxScore, results)
+			end
+
+			if minScore >= node.scores[0] && maxScore <= node.scores[1]
+				results << node.clone
+			end
+
+			return if maxScore < node.scores[0]
+
+			if node.right
+				stabNode(node.right, minScore, maxScore, results)
+			end
+		end
+	end
+end

data/lib/itree/version.rb

@@ -0,0 +1,3 @@
+module Intervals
+  VERSION = "0.1.0"
+end

data/spec/node_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe Intervals::Node do
+	context "creation" do
+		describe "#initialize" do
+			it { Intervals::Node.new(1,2,"taco").scores.should eq [1,2]}
+			it { Intervals::Node.new(1,2,"taco").data.should eq "taco"}
+			it { Intervals::Node.new(1,2,"taco").balance.should eq 0}
+			it { expect { Intervals::Node.new(2,1,"taco") }.to raise_error(ArgumentError)}
+		end
+	end
+
+	context "comparing" do
+		let(:lesser_min_node) { Intervals::Node.new(0,5,nil) }
+		let(:greater_min_node) { Intervals::Node.new(1,5,nil) }
+		let(:lesser_max_node) { Intervals::Node.new(0,5,nil) }
+		let(:greater_max_node) { Intervals::Node.new(0,1,nil) }
+
+		describe "#<=>" do
+			it { (lesser_min_node <=> greater_min_node).should eq -1 }
+			it { (lesser_min_node <=> lesser_min_node).should eq 0 }
+			it { (greater_min_node <=> lesser_min_node).should eq 1 }
+			it { (lesser_max_node <=> greater_max_node).should eq -1 }
+			it { (lesser_max_node <=> lesser_max_node).should eq 0 }
+			it { (greater_max_node <=> lesser_max_node).should eq 1 }
+		end
+
+		describe "#==" do
+			it { (lesser_min_node == lesser_min_node).should be true }
+			it { (lesser_min_node == greater_min_node).should_not be true }
+			it { (greater_min_node == greater_min_node).should be true }
+		end
+	end
+
+	describe "#resetBalance" do
+		let(:node) do
+			n = Intervals::Node.new(5,10,nil)
+			n.left = Intervals::Node.new(0,5,nil)
+			n.left.balance = 2
+			n.right = Intervals::Node.new(15,20,nil)
+			n.right.balance = 2
+			n
+		end
+
+		it "resets balance to 0" do
+			node.balance = 1
+			node.resetBalance
+			node.balance.should eq 0
+		end
+
+		context "when balance is -1" do
+			before(:each)  { node.balance = -1 }
+
+			it "sets left child balance to 0" do
+				node.resetBalance
+				node.left.balance.should eq 0
+			end
+
+			it "sets right child balance to 1" do
+				node.resetBalance
+				node.right.balance.should eq 1
+			end
+		end
+
+		context "when balance is 0" do
+			before(:each)  { node.balance = 0 }
+
+			it "sets left child balance to 0" do
+				node.resetBalance
+				node.left.balance.should eq 0
+			end
+
+			it "sets right child balance to 0" do
+				node.resetBalance
+				node.right.balance.should eq 0
+			end
+		end
+
+		context "when balance is 1" do
+			before(:each)  { node.balance = 1 }
+
+			it "sets left child balance to -1" do
+				node.resetBalance
+				node.left.balance.should eq -1
+			end
+
+			it "sets right child balance to 0" do
+				node.resetBalance
+				node.right.balance.should eq 0
+			end
+		end
+	end
+
+	describe "#updateMaxScores" do
+		let(:node) do
+			n = Intervals::Node.new(5,10,nil)
+			n.left = Intervals::Node.new(0,5,nil)
+			n.left.parent = n
+			n.right = Intervals::Node.new(15,20,nil)
+			n.right.parent = n
+			n.left.left = Intervals::Node.new(-2,0,nil)
+			n.left.left.parent = n.left
+			n.left.right = Intervals::Node.new(3,5,nil)
+			n.left.right.parent = n.left
+			n.right.left = Intervals::Node.new(10,15,nil)
+			n.right.left.parent = n.right
+			n.right.right = Intervals::Node.new(20,25,nil)
+			n.right.right.parent = n.right
+			n
+		end
+
+		context "left-left child has largest max score" do
+			before(:each) { node.left.left.scores[1] = 100 }
+
+			it "sets the maxLeftScore to the max score of the left-left child" do
+				node.left.left.updateMaxScores
+				node.subLeftMax.should eq node.left.left.scores[1]
+			end
+		end
+
+		context "left-right child has largest max score" do
+			before(:each) { node.left.right.scores[1] = 100 }
+
+			it "sets the maxLeftScore to the max score of the left-right child" do
+				node.left.right.updateMaxScores
+				node.subLeftMax.should eq node.left.right.scores[1]
+			end
+		end
+
+		context "right-left child has largest max score" do
+			before(:each) { node.right.left.scores[1] = 100 }
+
+			it "sets the maxRightScore to the max score of the right-left child" do
+				node.right.left.updateMaxScores
+				node.subRightMax.should eq node.right.left.scores[1]
+			end
+		end
+
+		context "right-right child has largest max score" do
+			before(:each) { node.right.right.scores[1] = 100 }
+
+			it "sets the maxRightScore to the max score of the right-right child" do
+				node.right.right.updateMaxScores
+				node.subRightMax.should eq node.right.right.scores[1]
+			end
+		end
+	end
+
+end

data/spec/tree_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+
+describe Intervals::Tree do
+	let(:tree) { Intervals::Tree.new }
+
+	context "creation" do
+		describe "#initialize" do
+			it { Intervals::Tree.new.size.should eq 0}
+			it { Intervals::Tree.new.root.should be nil}
+		end
+	end
+
+	describe "#insert" do
+		context "insert node in empty tree" do
+			it "inserts at root" do
+				tree.insert(0,10)
+				tree.root.scores.should eq [0,10]
+			end
+
+			it "increases tree size" do
+				tree.insert(0,10)
+				tree.size.should eq 1
+			end
+		end
+
+		context "inserting duplicates" do
+			before(:each) { tree.insert(0,10)}
+
+			it { tree.insert(0,10,"taco").should_not be true}
+			it "does not increase tree size" do
+				tree.insert(0,10,"taco")
+				tree.size.should_not eq 2
+			end
+		end
+
+		context "rotations" do
+			before(:each) do
+				tree.insert(150,250)
+				tree.insert(200,300)
+				tree.insert(100,200)
+			end
+
+			it { tree.root.scores.should eq [150,250] }
+			it { tree.root.left.scores.should eq [100,200] }
+			it { tree.root.right.scores.should eq [200,300] }
+			it { tree.size.should eq 3 }
+
+			context "left-left rotation" do
+				before(:each) do
+					tree.insert(25,50)
+					tree.insert(0,25)
+				end
+
+				it "does not change root" do
+					tree.root.scores.should eq [150,250]
+				end
+				it { tree.root.left.scores.should eq [25,50] }
+				it { tree.root.left.left.scores.should eq [0,25] }
+				it { tree.root.left.right.scores.should eq [100,200] }
+				it { tree.root.subLeftMax.should eq 200 }
+			end
+
+			context "right-right rotation" do
+				before(:each) do
+					tree.insert(250,300)
+					tree.insert(300,350)
+				end
+
+				it "does not change root" do
+					tree.root.scores.should eq [150,250]
+				end
+				it { tree.root.right.scores.should eq [250,300] }
+				it { tree.root.right.left.scores.should eq [200,300] }
+				it { tree.root.right.right.scores.should eq [300,350] }
+				it { tree.root.subRightMax.should eq 350 }
+			end
+
+			context "left-right rotation" do
+				before(:each) do
+					tree.insert(50,100)
+					tree.insert(75,125)
+				end
+
+				it "does not change root" do
+					tree.root.scores.should eq [150,250]
+				end
+				it { tree.root.left.scores.should eq [75,125] }
+				it { tree.root.left.left.scores.should eq [50,100] }
+				it { tree.root.left.right.scores.should eq [100,200] }
+				it { tree.root.subLeftMax.should eq 200 }
+			end
+
+			context "right-left rotation" do
+				before(:each) do
+					tree.insert(250,300)
+					tree.insert(225,275)
+				end
+
+				it "does not change root" do
+					tree.root.scores.should eq [150,250]
+				end
+				it { tree.root.right.scores.should eq [225,275] }
+				it { tree.root.right.left.scores.should eq [200,300] }
+				it { tree.root.right.right.scores.should eq [250,300] }
+				it { tree.root.subRightMax.should eq 300 }
+			end
+		end
+
+	end
+
+	describe "#insert!" do
+		context "inserting duplicates" do
+			before(:each) { tree.insert(0,10,"cheese")}
+
+			it { tree.root.data.should eq "cheese" }
+			it { tree.insert!(0,10,"taco").should_not be true}
+			it "does not increase tree size" do
+				tree.insert!(0,10,"taco")
+				tree.size.should_not eq 2
+			end
+			it "updates the node data" do
+				tree.insert!(0,10,"taco")
+				tree.root.data.should eq "taco"
+			end
+		end
+	end
+
+	describe "#remove" do
+		before(:each) do
+			tree.insert(100,200)
+			tree.insert(200,300)
+			tree.insert(150,250)
+			tree.insert(300,400)
+			tree.insert(400,500)
+			tree.insert(50,100)
+			tree.insert(75,125)
+			tree.insert(25,50)
+			tree.insert(0,25)
+			tree.insert(51,101)
+		end
+
+
+	end
+
+	describe "#stab" do
+		before(:each) do
+			tree.insert(100,200)
+			tree.insert(200,300)
+			tree.insert(150,250)
+			tree.insert(300,400)
+			tree.insert(400,500)
+			tree.insert(50,100)
+			tree.insert(75,125)
+			tree.insert(25,50)
+			tree.insert(0,25)
+			tree.insert(51,101)
+			tree.remove(100,200)
+			tree.remove(50,100)
+		end
+
+		it { tree.remove(0,25).should be true }
+		it { tree.remove(0,24).should be false }
+
+		it { tree.stab(23).length.should eq 1 }
+		it "returns a single range" do
+			results = tree.stab(23).map{|n| n.scores }.sort{|a,b| a[0] <=> b[0]}
+			results[0].should eq [0,25]
+		end
+
+		it { tree.stab(40).length.should eq 1 }
+		it "returns a single range" do
+			results = tree.stab(40).map{|n| n.scores }.sort{|a,b| a[0] <=> b[0]}
+			results[0].should eq [25,50]
+		end
+
+		it { tree.stab(77).length.should eq 2 }
+		it "returns two ranges" do
+			results = tree.stab(77).map{|n| n.scores }.sort{|a,b| a[0] <=> b[0]}
+			results[0].should eq [51,101]
+			results[1].should eq [75,125]
+		end
+
+		it { tree.stab(175).length.should eq 1 }
+		it "returns a single range" do
+			results = tree.stab(175).map{|n| n.scores }.sort{|a,b| a[0] <=> b[0]}
+			results[0].should eq [150,250]
+		end
+
+		it { tree.stab(350).length.should eq 1 }
+		it "returns a single range" do
+			results = tree.stab(350).map{|n| n.scores }.sort{|a,b| a[0] <=> b[0]}
+			results[0].should eq [300,400]
+		end
+	end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: itree
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Kenny Hoxworth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Interval Tree Data Structure
+email:
+- hoxworth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/itree/node.rb
+- lib/itree/tree.rb
+- lib/itree/version.rb
+- lib/itree.rb
+- spec/node_spec.rb
+- spec/tree_spec.rb
+homepage: http://github.com/hoxworth/itree
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Interval Tree Data Structure
+test_files:
+- spec/node_spec.rb
+- spec/tree_spec.rb