# the DICT object is automatically disconnected. the return value of the block
# is returned from this method.
# if an IRC message argument is passed, the error message will be replied
- def with_dict(m=nil &block)
+ def with_dict(m=nil, &block)
server, port = @bot.config['dictclient.server'].split ':' if @bot.config['dictclient.server']
server ||= 'dict.org'
port ||= DICT::DEFAULT_PORT
if results
results.collect {|database, matches|
@bot.config['dictclient.match_format'].gsub(
- '<matches>', matches.collect {|m| format_headword m}.join(', ')
+ '<matches>', matches.collect {|hit| format_headword hit}.join(', ')
).gsub(
'<database>', format_database(database)
)
def index(f)
fact = f.to_s
return if fact.empty?
- self.map { |f| f[:fact] }.index(fact)
+ self.map { |fs| fs[:fact] }.index(fact)
end
def delete(f)
jokers = q.registry[nick].jokers
rank = 0
- q.rank_table.each_index { |rank| break if nick.downcase == q.rank_table[rank][0].downcase }
- rank += 1
+ q.rank_table.each do |place|
+ rank += 1
+ break if nick.downcase == place[0].downcase
+ end
m.reply "#{nick}'s score is: #{score} Rank: #{rank} Jokers: #{jokers}"
else
stats = q.registry[nick]
# Find player in table
- found_player = false
- i = 0
- q.rank_table.each_index do |i|
- if nick.downcase == q.rank_table[i][0].downcase
- found_player = true
+ old_rank = nil
+ q.rank_table.each_with_index do |place, i|
+ if nick.downcase == place[0].downcase
+ old_rank = i
break
end
end
# Remove player from old position
- if found_player
- old_rank = i
- q.rank_table.delete_at( i )
- else
- old_rank = nil
+ if old_rank
+ q.rank_table.delete_at( old_rank )
end
# Insert player at new position
- inserted = false
- q.rank_table.each_index do |i|
- if stats.score > q.rank_table[i][1].score
+ new_rank = nil
+ q.rank_table.each_with_index do |place, i|
+ if stats.score > place[1].score
q.rank_table[i,0] = [[nick, stats]]
- inserted = true
+ new_rank = i
break
end
end
# If less than all other players' scores, append to table
- unless inserted
- i += 1 unless q.rank_table.empty?
+ unless new_rank
+ new_rank = q.rank_table.length
q.rank_table << [nick, stats]
end
# Print congratulations/condolences if the player's rank has changed
- unless old_rank.nil?
- if i < old_rank
- m.reply "#{nick} ascends to rank #{i + 1}. Congratulations :)"
- elsif i > old_rank
- m.reply "#{nick} slides down to rank #{i + 1}. So Sorry! NOT. :p"
+ if old_rank
+ if new_rank < old_rank
+ m.reply "#{nick} ascends to rank #{new_rank + 1}. Congratulations :)"
+ elsif new_rank > old_rank
+ m.reply "#{nick} slides down to rank #{new_rank + 1}. So Sorry! NOT. :p"
end
end
else
}
return false
end
- if p = get_player(user)
+ if pl = get_player(user)
announce _("%{p} is already playing %{uno} here") % {
- :p => p, :uno => UNO
+ :p => pl, :uno => UNO
}
return false
end
deal(p, @picker)
@picker = 0
end
- score = @players.inject(0) do |sum, p|
- if p.cards.length > 0
+ score = @players.inject(0) do |sum, pl|
+ if pl.cards.length > 0
announce _("%{p} still had %{cards}") % {
- :p => p, :cards => p.cards.join(' ')
+ :p => pl, :cards => pl.cards.join(' ')
}
- sum += p.cards.inject(0) do |cs, c|
+ sum += pl.cards.inject(0) do |cs, c|
cs += c.score
end
end
end
end
+ JUMP_TABLE = {
+ "ipinfodb" => Proc.new { |ip| ipinfodb(ip) },
+ "kapsi" => Proc.new { |ip| kapsi(ip) },
+ "geoiptool" => Proc.new { |ip| geoiptool(ip) },
+ }
+
def self.resolve(hostname, api)
raise InvalidHostError unless valid_host?(hostname)
raise InvalidHostError
end
- jump_table = {
- "ipinfodb" => Proc.new { |ip| ipinfodb(ip) },
- "kapsi" => Proc.new { |ip| kapsi(ip) },
- "geoiptool" => Proc.new { |ip| geoiptool(ip) },
- }
-
- raise BadAPIError unless jump_table.key?(api)
+ raise BadAPIError unless JUMP_TABLE.key?(api)
- return jump_table[api].call(ip)
+ return JUMP_TABLE[api].call(ip)
end
end
if m.replyto.class == Channel
# check if there is an user on the channel with nick same as input given
- user = m.replyto.users.find { |user| user.nick == params[:input] }
+ user = m.replyto.users.find { |usr| usr.nick == params[:input] }
if user
m.reply host2output(user.host, user.nick)
}
end
- urls.map { |url|
- info = info_name(url, :movies_by_year => true)
+ urls.map { |u|
+ info = info_name(u, :movies_by_year => true)
debug info.inspect
def get_parsed_data
return unless chunks = parse_chunks
- results = split_array_at(parse_chunks) {|chunk|chunk.customer?}
- results.map do |chunks|
+ results = split_array_at(chunks) {|chunk|chunk.customer?}
+ results.map do |data|
{
- :customer => chunks.select{|x|x.customer?}[0],
- :net => chunks.select{|x|x.network?}[0],
- :contacts => chunks.select{|x|x.contact?}
+ :customer => data.select{|x|x.customer?}[0],
+ :net => data.select{|x|x.network?}[0],
+ :contacts => data.select{|x|x.contact?}
}
end
end
elsif venue
begin
venues = search_venue_by(:name => venue.to_s, :limit => 1)
- rescue Exception => e
- error e
+ rescue Exception => err
+ error err
m.reply _("an error occurred looking for venue %{venue}: %{e}") % {
:venue => venue.to_s,
- :e => e.message
+ :e => err.message
}
end
if results > 0
begin
hits = []
- doc.root.each_element("results/trackmatches/track") do |track|
+ doc.root.each_element("results/trackmatches/track") do |trck|
hits << _("%{bold}%{t}%{bold} by %{bold}%{a}%{bold} (%{n} listeners)") % {
- :t => track.elements["name"].text,
- :a => track.elements["artist"].text,
- :n => track.elements["listeners"].text,
+ :t => trck.elements["name"].text,
+ :a => trck.elements["artist"].text,
+ :n => trck.elements["listeners"].text,
:bold => Bold
}
end
begin
res = @bot.httputil.get_response(uri)
raise _("no response body") unless res.body
- rescue Exception => e
- m.reply _("I had problems accessing last.fm: %{e}") % {:e => e.message}
+ rescue Exception => err
+ m.reply _("I had problems accessing last.fm: %{e}") % {:e => err.message}
return
end
doc = Document.new(res.body)
stop_watches
# Read watches from list.
- watchlist.each{ |handle, feed|
- watchRss(feed, m)
+ watchlist.each{ |hndl, fd|
+ watchRss(fd, m)
}
m.okay if m
end
debug xml.inspect
begin
doc = Document.new xml
- rescue REXML::ParseException => e
- warning e.inspect
- m.reply "couldn't parse output XML: #{e.class}"
+ rescue REXML::ParseException => err
+ warning err.inspect
+ m.reply "couldn't parse output XML: #{err.class}"
return
end
unless doc
return m.reply("#{Bold}#{word}#{Bold} not found") if rv.empty?
if notfound
- suggestions = rv.map { |s| Underline + s[1] + Underline }.uniq.join ', '
+ suggestions = rv.map { |str| Underline + str[1] + Underline }.uniq.join ', '
m.reply "#{Bold}#{word}#{Bold} not found. maybe you mean #{suggestions}?"
return
end
#
def initialize(cmd)
cmdpath = sanitize_command_path(cmd).split('::')
- seq = cmdpath.inject(["*"]) { |list, cmd|
- list << (list.length > 1 ? list.last + "::" : "") + cmd
+ seq = cmdpath.inject(["*"]) { |list, cc|
+ list << (list.length > 1 ? list.last + "::" : "") + cc
}
@path = seq.map { |k|
k.to_sym
def auth_list_users(m, params)
# TODO name regexp to filter results
- list = @bot.auth.save_array.inject([]) { |list, x| ['everyone', 'owner'].include?(x[:username]) ? list : list << x[:username] }
+ list = @bot.auth.save_array.inject([]) { |lst, x| ['everyone', 'owner'].include?(x[:username]) ? lst : lst << x[:username] }
if defined?(@destroy_q)
list.map! { |x|
@destroy_q.include?(x) ? x + _(" (queued for destruction)") : x
def load_filters(options={})
case options[:path]
when nil
- file = "#{self.dirname}.rb"
+ us = "#{self.dirname}.rb"
paths = [
- File.join(Config::datadir, 'filters', file),
- @bot.path('filters', file)
+ File.join(Config::datadir, 'filters', us),
+ @bot.path('filters', us)
]
when Array
paths = options[:path]
:method => :GET
}.merge(options)
- resp = nil
-
req_class = case opts[:method].to_s.downcase.intern
when :head, :"net::http::head"
opts[:max_redir] = -1
@@wordlist_base ||= Utils.bot.path 'wordlists'
end
- def self.get(path, options={})
+ def self.get(where, options={})
opts = { :spaces => false }.merge(options)
- wordlist_path = File.join(wordlist_base, path)
+ wordlist_path = File.join(wordlist_base, where)
raise "wordlist not found: #{wordlist_path}" unless File.exist?(wordlist_path)
# Location is a directory -> combine all lists beneath it
projects / user / henk / code / ruby / rbot.git / commitdiff