diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index fc5bd90..0000000
--- a/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/pkg
diff --git a/README.md b/README.md
deleted file mode 100644
index 03aab8a..0000000
--- a/README.md
+++ /dev/null
@@ -1,4 +0,0 @@
-Select
-======
-
-IO-Management select-based.
diff --git a/Rakefile b/Rakefile
index 2084b4a..01c6483 100644
--- a/Rakefile
+++ b/Rakefile
@@ -2,57 +2,56 @@ require 'rubygems'
 require 'rake'
 
 begin
-	require 'jeweler'
-	Jeweler::Tasks.new do |gem|
-		gem.name = "select"
-		gem.summary = %Q{IO-event-handler based on select}
-		gem.description = %Q{Select based event-handler for servers and sockets}
-		gem.email = "ich@denkn.at"
-		gem.license = 'LGPL-3.0'
-		gem.homepage = "http://github.com/DenisKnauf/select"
-		gem.authors = ["Denis Knauf"]
-		gem.files = %w[README.md VERSION lib/**/*.rb test/**/*.rb]
-		gem.require_paths = %w[lib]
-	end
-	Jeweler::GemcutterTasks.new
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "select"
+    gem.summary = %Q{IO-event-handler based on select}
+    gem.description = %Q{Select based event-handler for servers and sockets}
+    gem.email = "Denis.Knauf@gmail.com"
+    gem.homepage = "http://github.com/DenisKnauf/select"
+    gem.authors = ["Denis Knauf"]
+    gem.files = ["README", "VERSION", "lib/**/*.rb", "test/**/*.rb"]
+    gem.require_paths = ["lib"]
+  end
+  Jeweler::GemcutterTasks.new
 rescue LoadError
-	puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
 
 require 'rake/testtask'
 Rake::TestTask.new(:test) do |test|
-	test.libs << 'lib' << 'test' << 'ext'
-	test.pattern = 'test/**/*_test.rb'
-	test.verbose = true
+  test.libs << 'lib' << 'test' << 'ext'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
 end
 
 begin
-	require 'rcov/rcovtask'
-	Rcov::RcovTask.new do |test|
-		test.libs << 'test'
-		test.pattern = 'test/**/*_test.rb'
-		test.verbose = true
-	end
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
 rescue LoadError
-	task :rcov do
-		abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-	end
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
 end
 
 task :test => :check_dependencies
 
 task :default => :test
 
-require 'rdoc/task'
+require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|
-	if File.exist?('VERSION')
-		version = File.read('VERSION')
-	else
-		version = ""
-	end
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
 
-	rdoc.rdoc_dir = 'rdoc'
-	rdoc.title = "select #{version}"
-	rdoc.rdoc_files.include('README*')
-	rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sbdb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end
diff --git a/lib/select.rb b/lib/select.rb
index 306285a..1af7859 100644
--- a/lib/select.rb
+++ b/lib/select.rb
@@ -1,205 +1,89 @@
-# IO-Management
-# Fires if IO is ready a given block.
-#
-#   Select.open do |sel|
-#     sock = TCPSocket.new 'localhost', 8090
-#     buffer = ''
-#
-#     sel.on_read serv do |sock|
-#				buffer << sock.sysread
-#     end
-#
-#     sel.on_write STDOUT do |sock|
-#       return  if buffer.empty?
-#       written = sock.syswrite buffer
-#       buffer = buffer[written..-1]
-#     end
-#
-#     sel.on_error sock do |sock|
-#			  sel.close
-#     end
-#   end
-
 class Select
 	READ, WRITE, ERROR = 1, 2, 3
 
 	attr_reader :read, :write, :error
 	attr_accessor :exit, :exit_on_empty
 
-	# There are no events to wait?
 	def empty?
 		@read.empty? && @write.empty? && @error.empty?
 	end
 
-	class <<self
-		# Creates a new Select-instance.
-		# If you use a block, Select will close all IOs on end.
-		def self.new *args, &exe
-			r = super *args
-			if exe
-				yield r
-				r.close
-			else r
-			end
+	def self.new *p, &e
+		r = super *p
+		if e
+			e.call r
+			r.close
+		else r
 		end
-		alias open new
 	end
 
 	def initialize timeout = 30
-		@read, @write, @error, @times = {}, {}, {}, []
-		@read.default = @write.default = @error.default = proc{}
-		@timeout, @tevent, @exit, @exit_on_empty = timeout, proc{}, false, true
-		@pause = {read: {}, write: {}, error: {}}
+		@read, @write, @error = {}, {}, {}
+		@read.default = @write.default = @error.default = lambda{}
+		@timeout, @tevent, @exit = timeout, lambda{}, false
 	end
 
 	def timeout timeout = nil, &event
 		return @timeout  if timeout.nil?
-		raise ArgumentError, "Numeric value expected, not: '#{timeout}'"  unless Numeric === timeout
+		raise ArgumentError, "Numeric value expected, not: '#{timeout}'"  unless timeout.kind_of? Numeric
 		@timeout = timeout
 		@tevent = event  if event
 		timeout
 	end
 
-	def set io, type = :read, &event
-		#raise ArgumentError, "This io isn't supported: '#{io.inspect}'"  unless IO === io
-		#raise ArgumentError, "Unexpected Event: '#{event.inspect}'"  unless Proc === event
+	def set hook, type = :read, &event
+		raise ArgumentError, "This hook isn't supported: '#{hook.inspect}'"  unless hook.kind_of? IO
+		raise ArgumentError, "Unexpected Event: '#{event.inspect}'"  unless event.kind_of? Proc
 		case type
-		when  READ, :read   then  @read[ io] = event
-		when WRITE, :write  then @write[ io] = event
-		when ERROR, :error  then @error[ io] = event
-		when nil, :all
-			@read[ io] = event
-			@write[ io] = event
-			@error[ io] = event
-		else
-			raise ArgumentError, "Unknown event-type: '#{type}'"
+		when  READ, :read   then  @read[ hook] = event
+		when WRITE, :write  then @write[ hook] = event
+		when ERROR, :error  then @error[ hook] = event
+		when nil
+			@read[ hook] = event
+			@write[ hook] = event
+			@error[ hook] = event
+		else raise ArgumentError, "Unknown event-type: '#{type}'"
 		end
 	end
-	alias on set
 
-	def pause io, type = :read
+	def del hook, type = nil
 		case type
-		when  READ, :read   then @pause[ :read][  io] = @read.delete io
-		when WRITE, :write  then @pause[ :write][ io] = @write.delete io
-		when ERROR, :error  then @pause[ :error][ io] = @error.delete io
-		when nil, :all
-			@pause[ :read][ io] = @read.delete io
-			@pause[ :write][ io] = @write.delete io
-			@pause[ :error][ io] = @error.delete io
-		else
-			raise ArgumentError, "Unknown event-type: '#{type}'"
+		when  READ, :read   then @read.delete hook
+		when WRITE, :write  then @write.delete hook
+		when ERROR, :error  then @error.delete hook
+		when nil
+			@read.delete hook
+			@write.delete hook
+			@error.delete hook
+		else raise ArgumentError, "Unknown event-type: '#{type}'"
 		end
 	end
 
-	def unpause io, type = :read
-		case type
-		when  READ, :read   then @read[  io] = @pause[ :read].delete io
-		when WRITE, :write  then @write[ io] = @pause[ :write].delete io
-		when ERROR, :error  then @error[ io] = @pause[ :error].delete io
-		when nil, :all
-			@read[  io] = @pause[ :read].delete io
-			@write[ io] = @pause[ :write].delete io
-			@error[ io] = @pause[ :error].delete io
-		else
-			raise ArgumentError, "Unknown event-type: '#{type}'"
-		end
-	end
+	def  read_set( hook, &event)  self.set hook,  :read, &event  end
+	def write_set( hook, &event)  self.set hook, :write, &event  end
+	def error_set( hook, &event)  self.set hook, :error, &event  end
+	def  read_del( hook)   @read.delete hook  end
+	def write_del( hook)  @write.delete hook  end
+	def error_del( hook)  @error.delete hook  end
 
-	# Removes object from notification.
-	# If type is read/write/error, only this, else all.
-	def del io, type = nil
-		case type
-		when  READ, :read   then @read.delete io
-		when WRITE, :write  then @write.delete io
-		when ERROR, :error  then @error.delete io
-		when nil, :all
-			@read.delete io
-			@write.delete io
-			@error.delete io
-		else
-			raise ArgumentError, "Unknown event-type: '#{type}'"
-		end
-	end
-	alias off del
-
-	def  read_set( io, &event)  self.set io,  :read, &event  end
-	def write_set( io, &event)  self.set io, :write, &event  end
-	def error_set( io, &event)  self.set io, :error, &event  end
-	def  read_del( io)   @read.delete io  end
-	def write_del( io)  @write.delete io  end
-	def error_del( io)  @error.delete io  end
-	alias on_read read_set
-	alias on_write write_set
-	alias on_error error_set
-	alias off_read read_del
-	alias off_write write_del
-	alias off_error error_del
-
-	# only once this will be fired
-	def one io, type = :read, &exe
-		on io, type do |*args|
-			off io, type
-			yield *args
-		end
-	end
-
-	# Runs once.
-	# Every ready disposed to read/write or has an error, will be fired.
-	def run_once timeout = nil
-		timeout ||= @timeout
+	def run_once timeout = @timeout
 		r, w, e = Kernel.select( @read.keys, @write.keys, @error.keys, timeout)
-		r and r.each {|h|   @read[ h].call h, :read   }
-		w and w.each {|h|  @write[ h].call h, :write  }
-		e and e.each {|h|  @error[ h].call h, :error  }
+		return @tevent.call  unless r or w or e
+		r.each {|h|   @read[ h].call h, :read   }
+		w.each {|h|  @write[ h].call h, :write  }
+		e.each {|h|  @error[ h].call h, :error  }
 	end
 
-	# Runs in a loop
 	def run &e
 		if e
-			until @exit || (@exit_on_empty && empty?)
-				cron
-				self.run_once 1
+			until @exit || (@exit_on_empty && self.empty?)
+				self.run_once
 				e.call
 			end
 		else
-			until @exit || (@exit_on_empty && empty?)
-				cron
-				self.run_once 1
-			end
+			self.run_once  until @exit || (@exit_on_empty && self.empty?)
 		end
 	end
-
-	attr_reader :times
-	def cron
-		@times.each do |e|
-			return if e > Time.now
-			e.call
-			@times.shift
-		end
-	end
-
-	class Entry < Time
-		attr_reader :do
-		def do &e
-			@do = e
-		end
-
-		def call *p
-			@do.call *p
-		end
-
-		def self.new *a, &e
-			x = self.at *a
-			x.do &e
-			x
-		end
-	end
-
-	def at a, &e
-		a = Entry.new a, &e if e
-		@times << a
-		@times.sort!
-	end
 end
 
 class Select::Buffer <String
@@ -233,11 +117,11 @@ class Select::Socket
 		@select.error_set @sock, &method( :event_error)
 	end
 
-	def init sock: , delimiter: nil, select: nil, bufsize: nil, parent: nil
-		@sock    = sock
-		@select  = select  || Select.new
-		@bufsize = bufsize || 4096
-		@parent  = parent  || nil
+	def init opts
+		@select  = opts[ :select]  || Select.new
+		@sock    = opts[ :sock]    || raise( ArgumentError, "need sock")
+		@bufsize = opts[ :bufsize] || 4096
+		@parent  = opts[ :parent]  || nil
 		self.delimiter = opts[ :delimiter] || $/
 		@linebuf, @writebuf = Select::Buffer.new(""), Select::Buffer.new("")
 	end
@@ -323,10 +207,10 @@ class Select::Server
 		select.read_set @sock, &self.method( :event_conn)
 	end
 
-	def init sock: , select: nil, clientclass: nil
-		@sock = sock
-		@select = select || Select.new
-		@clientclass = clientclass || Select::Socket
+	def init opts
+		@sock = opts[ :sock] || raise( ArgumentError, "need sock")
+		@select = opts[ :select] || Select.new
+		@clientclass = opts[ :clientclass] || Select::Socket
 		@clients = []
 	end