butler 1.8.3 → 1.9.0

data/lib/butler/irc/message.rb

@@ -18,6 +18,8 @@ class Butler
 		# those messages easier, e.g. who (as Butler::IRC::User object) sent the
 		# message in which channel (Butler::IRC::Channel object) with what text.
 		# Raw message and raw parsed data are still available though.
+		# Don't create Butler::IRC::Message manually, leave that up to Butler::IRC::Client (which
+		# uses Butler::IRC::Parser to do that)
 		class Message
 			# the command-symbol, see COMMANDS (e.g. :PRIVMSG, :JOIN, ...)
 			attr_reader :symbol
@@ -31,8 +33,8 @@ class Butler
 			attr_reader :command
 			# the parameter part
 			attr_reader :params
-	
-			def initialize(client, symbol, raw, prefix, command, params)
+
+			def initialize(client, symbol, raw, prefix, command, params) # :nodoc:
 				@client  = client
 	
 				#raw message
@@ -70,30 +72,55 @@ class Butler
 				@symbol  = @fields[:symbol]
 			end
 			
+			# Answer a message in kind.
+			# * :NOTICE:  If the notice was sent to a channel, it will send a notice to the same channel,
+			#             if it was for a user, it will send a notice back to the sender
+			# * :PRIVMSG: If the privmsg was sent to a channel, it will send a privmsg to the same channel,
+			#             if it was for a user, it will send a privmsg back to the sender
+			# * All others: It will send a message to the channel the message was sent to.
 			def answer(text)
 				reply = channel || from
 				case @symbol
 					when :PRIVMSG: @client.irc.privmsg(text, reply)
 					when :NOTICE:  @client.irc.notice(text, reply)
+					when :JOIN, :PART, :KICK: @client.irc.privmsg(text, reply)
+					when :TOPIC, :NICK: @client.irc.privmsg(text, reply)
+					else
+						raise "Can't answer a #{@symbol} message."
 				end
 			end
 			
+			# If the server supports CAPAB IDENTIFY-MSG (informs irc clients whether the user sending a
+			# PRIVMSG/NOTICE is identified by nickserv), this method will tell you its value,
+			# returns true for messages prefixed with +, false for -, nil if not supported/activated.
 			def identified?
 				@fields[:identified]
 			end
 			
+			# The Butler::IRC::User the message is from.
 			def from
 				@fields[:from]
 			end
-	
+
+			# The Butler::IRC::User or Butler::IRC::Channel this message is for. If it's a User, it is
+			# most likely Butler::IRC::Client#myself.
 			def for
 				@fields[:for]
 			end
-	
+
+			# If the message was sent for/in a channel, this will be a Butler::IRC::Channel the message
+			# was sent for.
 			def channel
 				@fields[:channel]
 			end
-	
+
+			# Messages with text will use this attribute to store it. Prominent examples are:
+			# * :PRIVMSG - the message
+			# * :NOTICE - the message
+			# * :PART - part-reason
+			# * :QUIT - quit-reason
+			# * :KICK - kick-reason
+			# * :TOPIC - the new topic
 			def text
 				@fields[:text]
 			end
@@ -167,14 +194,6 @@ class Butler
 				@fields.dup
 			end
 			
-			def hash #:nodoc:
-				@raw.hash
-			end
-			
-			def eql?(other) #:nodoc:
-				@raw == other.raw
-			end
-			
 			def inspect #:nodoc:
 				fields = @fields.dup
 				#[:raw, :prefix, :command, :params, :command_raw]

data/lib/butler/irc/parser.rb

@@ -9,9 +9,11 @@
 require 'butler/irc/channellist'
 require 'butler/irc/hostmask'
 require 'butler/irc/message'
-require 'butler/irc/parser/commands'
+require 'butler/irc/parser/command'
 require 'butler/irc/string'
 require 'butler/irc/userlist'
+require 'log/comfort'
+require 'ostructfixed'
 require 'ruby/exception/detailed'
 require 'ruby/hash/zip'
 
@@ -24,28 +26,12 @@ class Butler
 		# regarding who myself is (out_of_sight, back_in_sight for users)
 		# allows creation of dialogs from privmsg and notice messages
 		class Parser
-			# RFC 2812, Parser itself uses a simplified matching
-			module Expressions
-				Special     = /[\[\]\\`_^{|}]/
-				Letter      = /[A-Za-z]/
-				Hex         = /[\dA-Fa-f]/
-				ChannelID   = /[A-Z\d]{5}/
-				Chanstring  = /[^\x00\x07\x10\x0D\x20,:]/
-				Channel     = /(?:[#+&]|!#{ChannelID})#{Chanstring}(?::#{Chanstring})?/
-				User        = /[^\x00\x10\x0D\x20@]/
-				Nick        = /[A-Za-z\[\]\\`_^{|}][A-Za-z\d\[\]\\`_^{|}-]*/
-				Command     = /[A-Za-z]+|\d{3}/
-				IP4addr     = /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
-				IP6addr     = /[\dA-Fa-f](?::[\dA-Fa-f]){7}|0:0:0:0:0:(?:0|[Ff]{4}):#{IP4addr}/
-				Hostaddr    = /#{IP4addr}|#{IP6addr}/
-				Shortname   = /[A-Za-z0-9][A-Za-z0-9-]*/
-				Hostname    = /#{Shortname}(?:\.#{Shortname})*/
-				Host        = /#{Hostname}|#{Hostaddr}/
-				Prefix      = /#{Hostname}|#{Nick}(?:(?:!#{User})?@#{Host})?/
-				Params      = /.*/ # FIXME
-				Message     = /(:#{Prefix} )?#{Command}(#{Params})?/
-			end
+
+			# enables chdirs, path to the command-sets
+			BasePath = (File.expand_path(File.dirname(__FILE__))+'/parser').freeze
 			
+			include Log::Comfort
+
 			class InvalidMessageFormat < RuntimeError; end
 			class UnknownCommand < RuntimeError; end
 			module ParseError
@@ -56,24 +42,75 @@ class Butler
 				end
 			end
 	
-			RMessage  = /\A(?::([^ \0]+) )?([A-Za-z\d]+|\d{3})(?: (.*))?\z/
-			RHostmask = /(#{Expressions::Nick})(?:(?:!(#{Expressions::User}))?@(#{Expressions::Host}))?/
-	
 			attr_reader :client
 			attr_reader :users
 			attr_reader :channels
 			attr_reader :commands
+			attr_reader :expression
+			attr_reader :isupport
 
 			attr_accessor :msg_identify
 	
 			def initialize(client, users, channels, *command_sets)
+				@logger       = nil
 				@client       = client
 				@users        = users
 				@channels     = channels
-				@commands     = Commands.new(*command_sets)
 				@msg_identify = false
+				@command_sets = command_sets
+				@isupport     = OpenStruct.new(
+					"nicklen"      => 8,
+					"channellen"   => 50,
+					"prefixes"     => "@+"
+				)
+				
+				reset
+			end
+
+			def same_nick?(a,b)
+				a.to_str.strip_user_prefixes.downcase == b.to_str.strip_user_prefixes.downcase
+			end
+			
+			def reset(isupport=nil)
+				@isupport   = OpenStruct.new(isupport) if isupport
+				@expression = OpenStruct.new
+				@commands   = Hash.new { |h,k| raise IndexError, "Unknown command #{k}" }
+				load(*@command_sets)
+				@expression.simple_message  = /\A(?::([^ \0]+) )?([A-Za-z\d]+|\d{3})(?: (.*))?\z/
+				@expression.simple_hostmask = /(#{expression.nick})(?:(?:!(#{expression.user}))?@(#{expression.host}))?/
+			end
+
+			def load(*files)
+				raise ArgumentError, "Requires at least one argument." if files.empty?
+				files.each { |name|
+					file = name.include?('/') ? name : "#{BasePath}/#{name}.rb"
+					instance_eval(File.read(file), file)
+					info("Loaded command set #{file}")
+				}
 			end
 			
+			def add_expression(name, value)
+				@expression[name] = value
+			end
+			
+			def alter_expression(name, value)
+				@expression[name] = value
+			end
+			
+			def add(raw, *args, &proc)
+				raise IndexError, "Command #{raw} is already registered. Did you want 'alter'?" if @commands.has_key?(raw)
+				@commands[raw.downcase] = Command.new(raw, *args, &proc)
+			end
+
+			def alter(raw, *args, &proc)
+				raise IndexError, "Command #{raw} is not registered. Did you want 'add'?" unless @commands.has_key?(raw)
+				@commands[raw.downcase] = Command.new(raw, *args, &proc)
+			end
+			
+			def inspect
+				"#<%s:0x%x>" %  [self.class, object_id]
+			end
+
 			# parses an incomming message and returns a Message object from which you
 			# can easily access parsed data.
 			# Expects the newlines to be already chomped off.
@@ -81,15 +118,15 @@ class Butler
 				prefix, command, params, symbol, from = nil
 	
 				# Basic analysis of the message
-				raise InvalidMessageFormat, raw unless matched = raw.match(RMessage)
+				raise InvalidMessageFormat, raw unless matched = raw.match(@expression.simple_message)
 				prefix, command, params	= *matched.captures
 				command.downcase!
 		
 				# Parse prefix if possible (<nick>!<user>@<host>)
-				from	= @users.create(*matched.captures) if prefix and matched = prefix.match(RHostmask)
-				
+				from	= @users.create(*matched.captures) if prefix and matched = prefix.match(@expression.simple_hostmask)
+
 				# in depth analyzis of the message
-				parser  = @commands[command]
+				parser  = @commands[command.downcase]
 				symbol  = parser.symbol
 				message	= Message.new(@client, symbol, raw, prefix, command, params)
 				message.alter_member(:from, from)

data/lib/butler/irc/parser/{commands.rb → command.rb}

@@ -14,44 +14,6 @@ require 'log/comfort'
 class Butler
 	module IRC
 		class Parser
-			class Commands
-				include Log::Comfort
-
-				# enables chdirs
-				BasePath = File.expand_path(File.dirname(__FILE__))
-
-				def initialize(*files)
-					@commands = Hash.new { |h,k| raise IndexError, "Unknown command #{k}" }
-					load(*files)
-				end
-				
-				def load(*files)
-					raise ArgumentError, "Requires at least one argument." if files.empty?
-					files.each { |file|
-						file = "#{BasePath}/#{file}.rb" unless file.include?('/')
-						instance_eval(File.read(file), file)
-					}
-				end
-				
-				def add(raw, *args, &proc)
-					raise IndexError, "Command #{raw} is already registered. Did you want 'alter'?" if @commands.has_key?(raw)
-					@commands[raw.downcase] = Command.new(raw, *args, &proc)
-				end
-	
-				def alter(raw, *args, &proc)
-					raise IndexError, "Command #{raw} is not registered. Did you want 'add'?" unless @commands.has_key?(raw)
-					@commands[raw.downcase] = Command.new(raw, *args, &proc)
-				end
-	
-				def [](raw)
-					@commands[raw.downcase]
-				end
-				
-				def inspect
-					"#<%s:0x%x>" %  [self.class, object_id]
-				end
-			end
-	
 			# Provides parsing information about specific commands.
 			class Command
 				attr_reader	:raw

data/lib/butler/irc/parser/generic.rb

@@ -5,35 +5,30 @@
 #++
 
 
+alter_expression :nick,       /[A-Za-z\[\]\\`_^{|}][A-Za-z\d\[\]\\`_^{|}-]{0,#{isupport.nicklen-1}}/
 
 # A list with all common, but non-rfc2812 IRC-Commands and their parsing
 # instructions.
 
 #
 alter("005", :ISUPPORT) { |message, parser|
-	hash = {
-		"CHANNELLEN" => 50,
-		"NICKLEN"    => 8,
-	}
-	message.params.sub(/\s+:.*?$/, '').split(/ /).each { |support|
+	hash = {}
+	message.params.sub(/\s+:.*?$/, '').split(/ /)[1..-1].each { |support|
 		name, value = support.split(/=/,2)
-		hash[name]  = case value
-			when nil
+		hash[name]  = case name
+			when "CAPAB"
 				true
-			when "NICKLEN"
+			when "CHANNELLEN", "NICKLEN", "MAXCHANNELS", "MODES", "TOPICLEN", "USERLEN", "KEYLEN"
 				value.to_i
 			when "PREFIX"
 				modes, prefixes = value[1..-1].split(/\)/, 2)
 				value = {}
 				modes.split(//).zip(prefixes.split(//)) { |k,v| value[k] = v }
 				value
-			when "MAXCHANNELS"
-				value.to_i
 			else value
 		end
 	}
 	message.create_member(:support, hash)
-	p hash
 }
 
 # Seen:
@@ -84,4 +79,6 @@ add("396", :RPL_HOSTHIDDEN, /^(\S+) (?:(.*?)@)?([:\S]+) :(.*)/, [:nick, :user, :
 	parser.users.myself.force_update(nil, message.displayed_host, nil)
 }
 
-add("505", :ERR__NOPRIVMSG)
+add("410", :ERR_SERVICES_OFFLINE)
+
+add("505", :ERR_NOPRIVMSG)

data/lib/butler/irc/parser/rfc2812.rb

@@ -10,6 +10,33 @@
 # Currently many of them are still in generic.rb
 
 
+# --- Regular expressions -------------------------------
+add_expression :special,    /[\[\]\\`_^{|}]/
+add_expression :letter,     /[A-Za-z]/
+add_expression :hex,        /[\dA-Fa-f]/
+add_expression :channel_id, /[A-Z\d]{5}/
+add_expression :chanstring, /[^\x00\x07\x10\x0D\x20,:]/
+add_expression :channel,    /(?:[#+&]|!#{expression.channel_id})#{expression.chanstring}(?::#{expression.chanstring})?/
+add_expression :user,       /[^\x00\x10\x0D\x20@]/
+add_expression :nick,       /[A-Za-z\[\]\\`_^{|}][A-Za-z\d\[\]\\`_^{|}-]{0,7}/
+add_expression :command,    /[A-Za-z]+|\d{3}/
+add_expression :ip4addr,    /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/
+add_expression :ip6addr,    /[\dA-Fa-f](?::[\dA-Fa-f]){7}|0:0:0:0:0:(?:0|[Ff]{4}):#{expression.ip4addr}/
+add_expression :hostaddr,   /#{expression.ip4addr}|#{expression.ip6addr}/
+add_expression :shortname,  /[A-Za-z0-9][A-Za-z0-9-]*/
+add_expression :hostname,   /#{expression.shortname}(?:\.#{expression.shortname})*/
+add_expression :host,       /#{expression.hostname}|#{expression.hostaddr}/
+add_expression :prefix,     /(#{expression.hostname})|(#{expression.nick})(?:(?:!(#{expression.user}))?@(#{expression.host}))?/
+add_expression :params,     /.*/ # FIXME
+add_expression :message,    /^
+# PREFIX
+(:#{expression.prefix}\x20)?
+# COMMAND
+(#{expression.command})
+# PARAMS
+(#{expression.params})?
+$/x
+
 
 # --- Text based ----------------------------------------
 add("error",   :ERROR)		# ERROR :<error-message>
@@ -19,6 +46,8 @@ add("join",    :JOIN,   /^:(.*)/,          [:channel]) { |message, parser|
 		message.from.add_channel(message.channel, :join)
 		message.channel.add_user(message.from, :join)
 	end
+	message.create_method(:private?) { false }
+	message.create_method(:public?) { true }
 }
 add("kick",    :KICK,   /^(\S*) (\S*) :(.*)/, [:channel, :for, :text]) { |message, parser|
 	parser.leave_channel(message, :kick, :kicked)
@@ -28,6 +57,8 @@ add("kill",    :KILL,   /^(\S*) (\S*) (.*)/, [:channel, :for, :text]) { |message
 		message.for.kill
 		parser.channels.delete_user(message.for, :kill)
 	end
+	message.create_method(:private?) { false }
+	message.create_method(:public?) { true }
 }
 add("mode",    :MODE,   /^(\S*) (.*)/, [:for, :arguments]) { |message, parser|
 	modifiers				= message[:arguments].split(" ")
@@ -61,6 +92,8 @@ add("mode",    :MODE,   /^(\S*) (.*)/, [:for, :arguments]) { |message, parser|
 add("nick",    :NICK,    /^:(.*)/, [:nick]) { |message, parser|
 	message.create_member(:old_nick, message.from.nick)
 	message.from.nick = message.nick if message.from
+	message.create_method(:private?) { false }
+	message.create_method(:public?) { true }
 }
 add("notice",  :NOTICE,  /(\S+) :(.*)/, [:for, :text]) { |message, parser|
 	if message.channel then
@@ -75,6 +108,8 @@ add("notice",  :NOTICE,  /(\S+) :(.*)/, [:for, :text]) { |message, parser|
 }
 add("part",    :PART,    /^([^\x00\x07\x10\x0D\x20,:]+)(?: :(.*))?/, [:channel, :reason]) { |message, parser|
 	parser.leave_channel(message, :part, :parted)
+	message.create_method(:private?) { false }
+	message.create_method(:public?) { true }
 }
 add("ping",    :PING,    /:(.*)/, [:pong])
 add("pong",    :PONG)
@@ -99,7 +134,10 @@ add("quit",    :QUIT,    /(.*)/, [:text]) { |message, parser|
 		parser.users.delete(message.from, :quit)
 	end
 }
-add("topic",   :TOPIC, /(\S+) :(.*)/, [:channel, :text])
+add("topic",   :TOPIC, /(\S+) :(.*)/, [:channel, :text]) { |message, parser|
+	message.create_method(:private?) { false }
+	message.create_method(:public?) { true }
+}
 
 
 
@@ -212,7 +250,7 @@ add("349", :RPL_ENDOFEXCEPTLIST)
 add("351", :RPL_VERSION)
 		# :irc.server.net 352 YourNickname <channel> <user> <host> <server> <nick> ( "H" / "G" > ["*"] [ ( "@" / "+" ) ] :<hopcount> <real name>
 add("352", :RPL_WHOREPLY,
-			/(\S+) (\S+) (\S+) (\S+) (\S+) (\S+) ([HG])[*%]{0,2}([@+-]{0,3}) :(\d+) (.*)/,
+			/(\S+) (\S+) (\S+) (\S+) (\S+) (\S+) ([HG])[*%]{0,2}([#{Regexp.escape(isupport.prefixes)}]{0,3}) :(\d+) (.*)/,
 			[:for, :channel, :user, :host, :server, :nick, :status, :flags, :hopcount, :real]) { |message, parser|
 #"for", "channel", "user", "host", "server", "nick", "status", "flags", "hopcount", "real"
 	user	= parser.users.create(message[:nick])

data/lib/butler/irc/socket.rb

@@ -26,14 +26,14 @@ class Butler
 		# parameters expecting a nickname will accept an Butler::IRC::User as well).
 		# It will adhere to its limit-settings, which will prevent from sending too
 		# many messages in a too short time to avoid excess flooding.
-		# Butler::IRC::Socket#write is the only synchronized method, since all other
-		# methods build up on it, IRC::Socket should be safe in threaded environments.
-		# Butler::IRC::Socket#read is NOT synchronized, so unless you read from only
-		# a single thread, statistics might get messed up.
+		# Butler::IRC::Socket#write_with_eol is the only synchronized method, since all
+		# other methods build up on it, IRC::Socket should be safe in threaded
+		# environments. Butler::IRC::Socket#read is NOT synchronized, so unless you
+		# read from only a single thread, statistics might get messed up.
 		# Length limits can only be safely guaranteed by specialized write methods,
-		# Butler::IRC::Socket#write will just warn and send the overlength message.
-		# If you are looking for queries (commands that get an answer from the server)
-		# take a look at Butler::IRC::Client.
+		# Butler::IRC::Socket#read from only will just warn and send the overlength
+		# message. If you are looking for queries (commands that get an answer from the
+		# server) take a look at Butler::IRC::Client.
 		# 
 		# ==Synopsis
 		# irc	= Butler::IRC::Socket.new('irc.freenode.org', :port => 6667, :charset => 'ISO-8859-1')
@@ -50,9 +50,6 @@ class Butler
 		# Errno::ECONNRESET:   connection works, server did not yet accept connection, resets after
 		# Errno::EPIPE:        writing to a server-side closed connection, nil on gets, connection was terminated
 		#
-		# ==FIXME
-		# mode commands don't test for length and split up
-		#
 		class Socket
 			VERSION	= "1.0.0"
 
@@ -73,6 +70,9 @@ class Butler
 			# contains limits for the protocol, burst times/counts etc.
 			attr_reader :limit
 			
+			# log raw out, will use log_out.puts(raw)
+			attr_accessor :log_out
+			
 			OptionsDefault = {
 				:port => 6667,
 				:eol  => "\r\n",
@@ -93,6 +93,7 @@ class Butler
 				@port         = options.delete(:port)
 				@eol          = options.delete(:eol).dup.freeze
 				@host         = options[:host] ? options.delete(:host).dup.freeze : options.delete(:host)
+				@log_out      = nil
 				@last_sent    = Time.new()
 				@count        = Hash.new(0)
 				@limit        = OpenStruct.new({
@@ -112,11 +113,16 @@ class Butler
 				@connected    = false
 				raise ArgumentError, "Unknown arguments: #{options.keys.inspect}" unless options.empty?
 			end
-		
+			
+			def connected?
+				@connected
+			end
+
 			# connects to the server
 			def connect
+				info("Connecting to #{@server} on port #{@port} from #{@host || '<default>'}")
 				@socket	= TCPSocket.open(@server, @port) #, @host)
-				info("Connected to #{@server}:#{@port} from #{@host || '<default>'}")
+				info("Successfully connected")
 			rescue ArgumentError => error
 				if @host then
 					warn("host-parameter is not supported by your ruby version. Parameter discarted.")
@@ -125,6 +131,8 @@ class Butler
 				else
 					raise
 				end
+			rescue Interrupt
+				raise
 			rescue Exception
 				error("Connection failed.")
 				raise
@@ -138,6 +146,7 @@ class Butler
 				if m = @socket.gets(@eol) then
 					m.chomp(@eol)
 				else
+					@connected = false
 					nil
 				end
 			end
@@ -147,7 +156,7 @@ class Butler
 			# you from several tasks like translating newlines, take care of overlength
 			# messages etc.
 			# FIXME, wrong methodname, write implies nothing is appended
-			def write(data)
+			def write_with_eol(data)
 				@mutex.synchronize {
 					warn("Raw too long (#{data.length} instead of #{@limit[:raw_length]})") if (data.length > @limit.raw_length)
 					now	= Time.now
@@ -185,6 +194,7 @@ class Butler
 					@count[:burst]  += 1
 					@count[:burst2] += 1
 					@count[:sent]   += 1
+					@log_out.puts(data) if @log_out
 				}
 			rescue IOError
 				error("Writing #{data.inspect} failed")
@@ -192,23 +202,24 @@ class Butler
 			end 
 	
 			# log into the irc-server (and connect if necessary)
-			def login(nickname, username, realname)
+			def login(nickname, username, realname, serverpass=nil)
 				connect unless @connected
-				write("NICK #{nickname}")
-				write("USER #{username} 0 * :#{realname}")
+				write_with_eol("PASS #{serverpass}") if serverpass
+				write_with_eol("NICK #{nickname}")
+				write_with_eol("USER #{username} 0 * :#{realname}")
 			end
 	
 			# identify nickname to nickserv
 			# FIXME, figure out what the server supports, possibly requires it
 			# to be moved to Butler::IRC::Client (to allow ghosting, nickchange, identify)
 			def identify(password)
-				write("NS :IDENTIFY #{password}")
+				write_with_eol("NS :IDENTIFY #{password}")
 			end
 			
 			# FIXME, figure out what the server supports, possibly requires it
 			# to be moved to Butler::IRC::Client (to allow ghosting, nickchange, identify)
 			def ghost(nickname, password)
-				write("NS :GHOST #{nickname} #{password}")
+				write_with_eol("NS :GHOST #{nickname} #{password}")
 			end
 			
 			def normalize_message(message, limit=:message_length)
@@ -225,7 +236,7 @@ class Butler
 			def privmsg(message, *recipients)
 				normalize_message(message).each { |message|
 					recipients.each { |recipient|
-						write("PRIVMSG #{recipient} :#{message}")
+						write_with_eol("PRIVMSG #{recipient} :#{message}")
 					}
 				}
 			end
@@ -234,7 +245,7 @@ class Butler
 			def action(message, *recipients)
 				normalize_message(message).each { |message|
 					recipients.each { |recipient|
-						write("PRIVMSG #{recipient} :"+(1.chr)+"ACTION "+message+(1.chr))
+						write_with_eol("PRIVMSG #{recipient} :"+(1.chr)+"ACTION "+message+(1.chr))
 					}
 				}
 			end
@@ -246,7 +257,7 @@ class Butler
 			def notice(message, *recipients)
 				normalize_message(message).each { |message|
 					recipients.each { |recipient|
-						write("NOTICE #{recipient} :#{message}")
+						write_with_eol("NOTICE #{recipient} :#{message}")
 					}
 				}
 			end
@@ -254,9 +265,9 @@ class Butler
 			# send a pong
 			def pong(*args)
 				if args.empty? then
-					write("PONG")
+					write_with_eol("PONG")
 				else
-					write("PONG #{args.join(' ')}")
+					write_with_eol("PONG #{args.join(' ')}")
 				end
 			end
 	
@@ -266,9 +277,9 @@ class Butler
 			def join(*channels)
 				channels.map { |channel, password|
 					if password then
-						write("JOIN #{channel} #{password}")
+						write_with_eol("JOIN #{channel} #{password}")
 					else
-						write("JOIN #{channel}")
+						write_with_eol("JOIN #{channel}")
 					end
 					channel
 				}
@@ -285,80 +296,94 @@ class Butler
 
 				# some servers still can't process lists of channels in part
 				channels.each { |channel|
-					write("PART #{channel} #{reason}")
+					write_with_eol("PART #{channel} #{reason}")
 				}
 			end
 	
 			# set your own nick
 			# does NO verification/validation of any kind
 			def nick(nick)
-				write("NICK #{nick}")
+				write_with_eol("NICK #{nick}")
 			end
 	
 			# set your status to away with reason 'reason'
 			def away(reason="")
 				return back if reason.empty?
-				write("AWAY :#{reason}")
+				write_with_eol("AWAY :#{reason}")
 			end
 	
 			# reset your away status to back
 			def back
-				write("AWAY")
+				write_with_eol("AWAY")
 			end
 	
 			# kick user in channel with reason
 			def kick(user, channel, reason)
-				write("KICK #{channel} #{user} :#{reason}")
+				write_with_eol("KICK #{channel} #{user} :#{reason}")
 			end
 			
 			# send a mode command to a channel
 			def mode(channel, mode)
-				write("MODE #{channel} #{mode}")
+				write_with_eol("MODE #{channel} #{mode}")
 			end
 			
+			# Give Op to user in channel
+			# User can be a nick or IRC::User, either one or an array.
+			def multiple_mode(channel, pre, flag, targets)
+				(0...targets.length).step(10) { |i|
+					slice = targets[i,10]
+					write_with_eol("MODE #{channel} +#{flag*slice.length} #{slice*' '}")
+				}
+			end
+	
 			# Give Op to user in channel
 			# User can be a nick or IRC::User, either one or an array.
 			def op(channel, *users)
-				write("MODE #{channel} +#{'o'*users.length} #{users*' '}")
+				multiple_mode(channel, '+', 'o', users)
 			end
 	
 			# Take Op from user in channel
 			# User can be a nick or IRC::User, either one or an array.
 			def deop(channel, *users)
-				write("MODE #{channel} -#{'o'*users.length} #{users*' '}")
+				multiple_mode(channel, '-', 'o', users)
 			end
 	
 			# Give voice to user in channel
 			# User can be a nick or IRC::User, either one or an array.
 			def voice(channel, *users)
-				write("MODE #{channel} +#{'v'*users.length} #{users*' '}")
+				multiple_mode(channel, '+', 'v', users)
 			end
 	
 			# Take voice from user in channel.
 			# User can be a nick or IRC::User, either one or an array.
 			def devoice(channel, *users)
-				write("MODE #{channel} -#{'v'*users.length} #{users*' '}")
+				multiple_mode(channel, '-', 'v', users)
 			end
 	
 			# Set ban in channel to mask
-			def ban(mask, channel)
-				write("MODE #{channel} +b #{mask}")
+			def ban(channel, *masks)
+				multiple_mode(channel, '+', 'b', masks)
 			end
 	
+			# Remove ban in channel to mask
+			def unban(channel, *masks)
+				multiple_mode(channel, '-', 'b', masks)
+			end
+
 			# Send a "who" to channel
 			def who(channel)
-				write("WHO #{channel}")
+				write_with_eol("WHO #{channel}")
 			end
 	
 			# Send a "whois" to server
 			def whois(nick)
-				write("WHOIS #{nick}")
+				write_with_eol("WHOIS #{nick}")
 			end
 	
 			# send the quit message to the server
 			# if you set close to true it will also close the socket
 			def quit(reason="leaving", close=false)
-				write("QUIT :#{reason}")
+				write_with_eol("QUIT :#{reason}")
 				close() if close
 			end
 	
@@ -381,4 +406,4 @@ class Butler
 			end
 		end
 	end
-end
+end