diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..fc5bd90
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/pkg
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..03aab8a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,4 @@
+Select
+======
+
+IO-Management select-based.
diff --git a/Rakefile b/Rakefile
index 01c6483..2084b4a 100644
--- a/Rakefile
+++ b/Rakefile
@@ -2,56 +2,57 @@ 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 = "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
+	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
 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 'rake/rdoctask'
+require 'rdoc/task'
 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 = "sbdb #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+	rdoc.rdoc_dir = 'rdoc'
+	rdoc.title = "select #{version}"
+	rdoc.rdoc_files.include('README*')
+	rdoc.rdoc_files.include('lib/**/*.rb')
 end
diff --git a/lib/select.rb b/lib/select.rb
index 1af7859..306285a 100644
--- a/lib/select.rb
+++ b/lib/select.rb
@@ -1,89 +1,205 @@
+# 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
 
-	def self.new *p, &e
-		r = super *p
-		if e
-			e.call r
-			r.close
-		else r
+	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
 		end
+		alias open new
 	end
 
 	def initialize timeout = 30
-		@read, @write, @error = {}, {}, {}
-		@read.default = @write.default = @error.default = lambda{}
-		@timeout, @tevent, @exit = timeout, lambda{}, false
+		@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: {}}
 	end
 
 	def timeout timeout = nil, &event
 		return @timeout  if timeout.nil?
-		raise ArgumentError, "Numeric value expected, not: '#{timeout}'"  unless timeout.kind_of? Numeric
+		raise ArgumentError, "Numeric value expected, not: '#{timeout}'"  unless Numeric === timeout
 		@timeout = timeout
 		@tevent = event  if event
 		timeout
 	end
 
-	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
+	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
 		case 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}'"
+		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}'"
+		end
+	end
+	alias on set
+
+	def pause io, type = :read
+		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}'"
 		end
 	end
 
-	def del hook, type = nil
+	def unpause io, type = :read
 		case 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}'"
+		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 run_once timeout = @timeout
+	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
 		r, w, e = Kernel.select( @read.keys, @write.keys, @error.keys, timeout)
-		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  }
+		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  }
 	end
 
+	# Runs in a loop
 	def run &e
 		if e
-			until @exit || (@exit_on_empty && self.empty?)
-				self.run_once
+			until @exit || (@exit_on_empty && empty?)
+				cron
+				self.run_once 1
 				e.call
 			end
 		else
-			self.run_once  until @exit || (@exit_on_empty && self.empty?)
+			until @exit || (@exit_on_empty && empty?)
+				cron
+				self.run_once 1
+			end
 		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
@@ -117,11 +233,11 @@ class Select::Socket
 		@select.error_set @sock, &method( :event_error)
 	end
 
-	def init opts
-		@select  = opts[ :select]  || Select.new
-		@sock    = opts[ :sock]    || raise( ArgumentError, "need sock")
-		@bufsize = opts[ :bufsize] || 4096
-		@parent  = opts[ :parent]  || nil
+	def init sock: , delimiter: nil, select: nil, bufsize: nil, parent: nil
+		@sock    = sock
+		@select  = select  || Select.new
+		@bufsize = bufsize || 4096
+		@parent  = parent  || nil
 		self.delimiter = opts[ :delimiter] || $/
 		@linebuf, @writebuf = Select::Buffer.new(""), Select::Buffer.new("")
 	end
@@ -207,10 +323,10 @@ class Select::Server
 		select.read_set @sock, &self.method( :event_conn)
 	end
 
-	def init opts
-		@sock = opts[ :sock] || raise( ArgumentError, "need sock")
-		@select = opts[ :select] || Select.new
-		@clientclass = opts[ :clientclass] || Select::Socket
+	def init sock: , select: nil, clientclass: nil
+		@sock = sock
+		@select = select || Select.new
+		@clientclass = clientclass || Select::Socket
 		@clients = []
 	end