# these first
require 'rbot/rbotconfig'
require 'rbot/config'
-require 'rbot/utils'
+# require 'rbot/utils'
require 'rbot/irc'
require 'rbot/rfc2812'
require 'rbot/language'
require 'rbot/dbhash'
require 'rbot/registry'
-require 'rbot/httputil'
+# require 'rbot/httputil'
module Irc
:validate => Proc.new { |v| v > 0 },
:desc => "Maximum console messages logfile size (in megabytes)")
+ BotConfig.register BotConfigEnumValue.new('send.newlines',
+ :values => ['split', 'join'], :default => 'split',
+ :on_change => Proc.new { |bot, v|
+ bot.set_default_send_options :newlines => v.to_sym
+ },
+ :desc => "When set to split, messages with embedded newlines will be sent as separate lines. When set to join, newlines will be replaced by the value of join_with")
+ BotConfig.register BotConfigStringValue.new('send.join_with',
+ :default => ' ',
+ :on_change => Proc.new { |bot, v|
+ bot.set_default_send_options :join_with => v.dup
+ },
+ :desc => "String used to replace newlines when send.newlines is set to join")
+ BotConfig.register BotConfigIntegerValue.new('send.max_lines',
+ :default => 0,
+ :validate => Proc.new { |v| v >= 0 },
+ :on_change => Proc.new { |bot, v|
+ bot.set_default_send_options :max_lines => v
+ },
+ :desc => "Maximum number of IRC lines to send for each message (set to 0 for no limit)")
+ BotConfig.register BotConfigEnumValue.new('send.overlong',
+ :values => ['split', 'truncate'], :default => 'split',
+ :on_change => Proc.new { |bot, v|
+ bot.set_default_send_options :overlong => v.to_sym
+ },
+ :desc => "When set to split, messages which are too long to fit in a single IRC line are split into multiple lines. When set to truncate, long messages are truncated to fit the IRC line length")
+ BotConfig.register BotConfigStringValue.new('send.split_at',
+ :default => '\s+',
+ :on_change => Proc.new { |bot, v|
+ bot.set_default_send_options :split_at => Regexp.new(v)
+ },
+ :desc => "A regular expression that should match the split points for overlong messages (see send.overlong)")
+ BotConfig.register BotConfigBooleanValue.new('send.purge_split',
+ :default => true,
+ :on_change => Proc.new { |bot, v|
+ bot.set_default_send_options :purge_split => v
+ },
+ :desc => "Set to true if the splitting boundary (set in send.split_at) should be removed when splitting overlong messages (see send.overlong)")
+ BotConfig.register BotConfigStringValue.new('send.truncate_text',
+ :default => "#{Reverse}...#{Reverse}",
+ :on_change => Proc.new { |bot, v|
+ bot.set_default_send_options :truncate_text => v.dup
+ },
+ :desc => "When truncating overlong messages (see send.overlong) or when sending too many lines per message (see send.max_lines) replace the end of the last line with this text")
+
@argv = params[:argv]
unless FileTest.directory? Config::coredir
Dir.mkdir("#{botclass}/logs") unless File.exist?("#{botclass}/logs")
Dir.mkdir("#{botclass}/registry") unless File.exist?("#{botclass}/registry")
Dir.mkdir("#{botclass}/safe_save") unless File.exist?("#{botclass}/safe_save")
- Utils.set_safe_save_dir("#{botclass}/safe_save")
# Time at which the last PING was sent
@last_ping = nil
end
def STDOUT.write(str=nil)
log str, 2
- return str.to_s.length
+ return str.to_s.size
end
def STDERR.write(str=nil)
if str.to_s.match(/:\d+: warning:/)
else
error str, 2
end
- return str.to_s.length
+ return str.to_s.size
end
end
@logs = Hash.new
- @httputil = Utils::HttpUtil.new(self)
-
@plugins = nil
@lang = Language::Language.new(self, @config['core.language'])
Dir.mkdir("#{botclass}/plugins") unless File.exist?("#{botclass}/plugins")
@plugins = Plugins::pluginmanager
@plugins.bot_associate(self)
+ @plugins.add_botmodule_dir(Config::coredir + "/utils")
@plugins.add_botmodule_dir(Config::coredir)
@plugins.add_botmodule_dir("#{botclass}/plugins")
@plugins.add_botmodule_dir(Config::datadir + "/plugins")
@plugins.scan
+ Utils.set_safe_save_dir("#{botclass}/safe_save")
+ @httputil = Utils::HttpUtil.new(self)
+
+
@socket = IrcSocket.new(@config['server.name'], @config['server.port'], @config['server.bindhost'], @config['server.sendq_delay'], @config['server.sendq_burst'], :ssl => @config['server.ssl'])
@client = IrcClient.new
myself.nick = @config['irc.nick']
# Channels where we are quiet
- # It's nil when we are not quiet, an empty list when we are quiet
- # in all channels, a list of channels otherwise
- @quiet = nil
+ # Array of channels names where the bot should be quiet
+ # '*' means all channels
+ #
+ @quiet = []
@client[:welcome] = proc {|data|
irclog "joined server #{@client.server} as #{myself}", "server"
unless ignored
@plugins.delegate "listen", m
@plugins.privmsg(m) if m.address?
+ if not m.replied
+ @plugins.delegate "unreplied", m
+ end
end
}
@client[:notice] = proc { |data|
irclog data[:serverstring], ".unknown"
}
- set_default_send_options
+ set_default_send_options :newlines => @config['send.newlines'].to_sym,
+ :join_with => @config['send.join_with'].dup,
+ :max_lines => @config['send.max_lines'],
+ :overlong => @config['send.overlong'].to_sym,
+ :split_at => Regexp.new(@config['send.split_at']),
+ :purge_split => @config['send.purge_split'],
+ :truncate_text => @config['send.truncate_text'].dup
end
- def set_default_send_options
+ def set_default_send_options(opts={})
# Default send options for NOTICE and PRIVMSG
- # TODO document, for plugin writers
- # TODO some of these options, like :truncate_text and :max_lines,
- # should be made into config variables that trigger this routine on change
- @default_send_options = {
- :queue_channel => nil, # use default queue channel
- :queue_ring => nil, # use default queue ring
- :newlines => :split, # or :join
- :join_with => ' ', # by default, use a single space
- :max_lines => nil, # maximum number of lines to send with a single command
- :overlong => :split, # or :truncate
- # TODO an array of splitpoints would be preferrable for this option:
- :split_at => /\s+/, # by default, split overlong lines at whitespace
- :purge_split => true, # should the split string be removed?
- :truncate_text => "#{Reverse}...#{Reverse}" # text to be appened when truncating
- }
- end
+ unless defined? @default_send_options
+ @default_send_options = {
+ :queue_channel => nil, # use default queue channel
+ :queue_ring => nil, # use default queue ring
+ :newlines => :split, # or :join
+ :join_with => ' ', # by default, use a single space
+ :max_lines => 0, # maximum number of lines to send with a single command
+ :overlong => :split, # or :truncate
+ # TODO an array of splitpoints would be preferrable for this option:
+ :split_at => /\s+/, # by default, split overlong lines at whitespace
+ :purge_split => true, # should the split string be removed?
+ :truncate_text => "#{Reverse}...#{Reverse}" # text to be appened when truncating
+ }
+ end
+ @default_send_options.update opts unless opts.empty?
+ end
# checks if we should be quiet on a channel
def quiet_on?(channel)
- return false unless @quiet
- return true if @quiet.empty?
- return @quiet.include?(channel.to_s)
+ return @quiet.include?('*') || @quiet.include?(channel.downcase)
end
- def set_quiet(channel=nil)
+ def set_quiet(channel)
if channel
- @quiet << channel.to_s unless @quiet.include?(channel.to_s)
+ ch = channel.downcase.dup
+ @quiet << ch unless @quiet.include?(ch)
else
- @quiet = []
+ @quiet.clear
+ @quiet << '*'
end
end
- def reset_quiet(channel=nil)
+ def reset_quiet(channel)
if channel
- @quiet.delete_if { |x| x == channel.to_s }
+ @quiet.delete channel.downcase
else
- @quiet = nil
+ @quiet.clear
end
end
lines = Array.new
message.each_line { |line|
line.chomp!
- next unless(line.length > 0)
+ next unless(line.size > 0)
lines << line
}
else
# The maximum raw message length we can send is therefore 512 - 2 - 2
# minus the length of our hostmask.
- max_len = 508 - myself.fullform.length
+ max_len = 508 - myself.fullform.size
# On servers that support IDENTIFY-MSG, we have to subtract 1, because messages
# will have a + or - prepended
fixed = "#{type} #{where} :"
# And this is what's left
- left = max_len - fixed.length
+ left = max_len - fixed.size
case opts[:overlong]
when :split
split_at = opts[:split_at]
when :truncate
truncate = opts[:truncate_text]
- truncate = @default_send_options[:truncate_text] if truncate.length > left
- truncate = "" if truncate.length > left
+ truncate = @default_send_options[:truncate_text] if truncate.size > left
+ truncate = "" if truncate.size > left
else
raise "Unknown :overlong option #{opts[:overlong]} while sending #{original_message.inspect}"
end
# Counter to check the number of lines sent by this command
cmd_lines = 0
max_lines = opts[:max_lines]
+ maxed = false
line = String.new
lines.each { |msg|
begin
- if(left >= msg.length)
+ if max_lines > 0 and cmd_lines == max_lines - 1
+ truncate = opts[:truncate_text]
+ truncate = @default_send_options[:truncate_text] if truncate.size > left
+ truncate = "" if truncate.size > left
+ maxed = true
+ end
+ if(left >= msg.size) and not maxed
sendq "#{fixed}#{msg}", chan, ring
log_sent(type, where, msg)
- return
- end
- if opts[:max_lines] and cmd_lines == max_lines - 1
- debug "Max lines count reached for message #{original_message.inspect} while sending #{msg.inspect}, truncating"
- truncate = opts[:truncate_text]
- truncate = @default_send_options[:truncate_text] if truncate.length > left
- truncate = "" if truncate.length > left
+ cmd_lines += 1
+ break
end
if truncate
- line.replace msg.slice(0, left-truncate.length)
- line.sub!(/\s+\S*$/, truncate)
- raise "PROGRAMMER ERROR! #{line.inspect} of length #{line.length} > #{left}" if line.length > left
+ line.replace msg.slice(0, left-truncate.size)
+ # line.sub!(/\s+\S*$/, truncate)
+ line << truncate
+ raise "PROGRAMMER ERROR! #{line.inspect} of size #{line.size} > #{left}" if line.size > left
sendq "#{fixed}#{line}", chan, ring
log_sent(type, where, line)
return
line.replace msg.slice!(0, left)
lastspace = line.rindex(opts[:split_at])
if(lastspace)
- msg.replace line.slice!(lastspace, line.length) + msg
+ msg.replace line.slice!(lastspace, line.size) + msg
msg.gsub!(/^#{opts[:split_at]}/, "") if opts[:purge_split]
end
sendq "#{fixed}#{line}", chan, ring
log_sent(type, where, line)
- cmd_lines += 1
- end while(msg.length > 0)
+ cmd_lines += 1
+ end while(msg.size > 0)
}
end
# send a notice message to channel/nick +where+
def notice(where, message, options={})
- unless quiet_on?(where)
- sendmsg "NOTICE", where, message, options
- end
+ return if where.kind_of?(Channel) and quiet_on?(where)
+ sendmsg "NOTICE", where, message, options
end
# say something (PRIVMSG) to channel/nick +where+
def say(where, message, options={})
- unless quiet_on?(where)
- sendmsg "PRIVMSG", where, message, options
- end
+ return if where.kind_of?(Channel) and quiet_on?(where)
+ sendmsg "PRIVMSG", where, message, options
end
# perform a CTCP action with message +message+ to channel/nick +where+
def action(where, message, options={})
+ return if where.kind_of?(Channel) and quiet_on?(where)
mchan = options.fetch(:queue_channel, nil)
mring = options.fetch(:queue_ring, nil)
if mchan
projects / user / henk / code / ruby / rbot.git / blobdiff