git.oblomov.eu Git - rbot/blob - data/rbot/plugins/rss.rb

   1 #-- vim:sw=2:et\r
   2 #++\r
   3 #\r
   4 # RSS feed plugin for RubyBot\r
   5 # (c) 2004 Stanislav Karchebny <berkus@madfire.net>\r
   6 # (c) 2005 Ian Monroe <ian@monroe.nu>\r
   7 # (c) 2005 Mark Kretschmann <markey@web.de>\r
   8 # (c) 2006 Giuseppe Bilotta <giuseppe.bilotta@gmail.com>\r
   9 #\r
  10 # Licensed under MIT License.\r
  11 \r
  12 require 'rss/parser'\r
  13 require 'rss/1.0'\r
  14 require 'rss/2.0'\r
  15 require 'rss/dublincore'\r
  16 # begin\r
  17 #   require 'rss/dublincore/2.0'\r
  18 # rescue\r
  19 #   warning "Unable to load RSS libraries, RSS plugin functionality crippled"\r
  20 # end\r
  21 \r
  22 class ::RssBlob\r
  23   attr_accessor :url\r
  24   attr_accessor :handle\r
  25   attr_accessor :type\r
  26   attr :watchers\r
  27   attr_accessor :refresh_rate\r
  28   attr_accessor :xml\r
  29   attr_accessor :title\r
  30   attr_accessor :items\r
  31   attr_accessor :mutex\r
  32 \r
  33   def initialize(url,handle=nil,type=nil,watchers=[], xml=nil)\r
  34     @url = url\r
  35     if handle\r
  36       @handle = handle\r
  37     else\r
  38       @handle = url\r
  39     end\r
  40     @type = type\r
  41     @watchers=[]\r
  42     @refresh_rate = nil\r
  43     @xml = xml\r
  44     @title = nil\r
  45     @items = nil\r
  46     @mutex = Mutex.new\r
  47     sanitize_watchers(watchers)\r
  48   end\r
  49 \r
  50   def dup\r
  51     self.class.new(@url,\r
  52                    @handle,\r
  53                    @type ? @type.dup : nil,\r
  54                    @watchers.dup,\r
  55                    @xml ? @xml.dup : nil)\r
  56   end\r
  57 \r
  58   # Downcase all watchers, possibly turning them into Strings if they weren't\r
  59   def sanitize_watchers(list=@watchers)\r
  60     ls = list.dup\r
  61     @watchers.clear\r
  62     ls.each { |w|\r
  63       add_watch(w)\r
  64     }\r
  65   end\r
  66 \r
  67   def watched?\r
  68     !@watchers.empty?\r
  69   end\r
  70 \r
  71   def watched_by?(who)\r
  72     @watchers.include?(who.downcase)\r
  73   end\r
  74 \r
  75   def add_watch(who)\r
  76     if watched_by?(who)\r
  77       return nil\r
  78     end\r
  79     @watchers << who.downcase\r
  80     return who\r
  81   end\r
  82 \r
  83   def rm_watch(who)\r
  84     @watchers.delete(who.downcase)\r
  85   end\r
  86 \r
  87   def to_a\r
  88     [@handle,@url,@type,@refresh_rate,@watchers]\r
  89   end\r
  90 \r
  91   def to_s(watchers=false)\r
  92     if watchers\r
  93       a = self.to_a.flatten\r
  94     else\r
  95       a = self.to_a[0,3]\r
  96     end\r
  97     a.compact.join(" | ")\r
  98   end\r
  99 end\r
 100 \r
 101 class RSSFeedsPlugin < Plugin\r
 102   BotConfig.register BotConfigIntegerValue.new('rss.head_max',\r
 103     :default => 30, :validate => Proc.new{|v| v > 0 && v < 200},\r
 104     :desc => "How many characters to use of a RSS item header")\r
 105 \r
 106   BotConfig.register BotConfigIntegerValue.new('rss.text_max',\r
 107     :default => 90, :validate => Proc.new{|v| v > 0 && v < 400},\r
 108     :desc => "How many characters to use of a RSS item text")\r
 109 \r
 110   BotConfig.register BotConfigIntegerValue.new('rss.thread_sleep',\r
 111     :default => 300, :validate => Proc.new{|v| v > 30},\r
 112     :desc => "How many seconds to sleep before checking RSS feeds again")\r
 113 \r
 114   def initialize\r
 115     super\r
 116     if @registry.has_key?(:feeds)\r
 117       @feeds = @registry[:feeds]\r
 118       @feeds.keys.grep(/[A-Z]/) { |k|\r
 119         @feeds[k.downcase] = @feeds[k]\r
 120         @feeds.delete(k)\r
 121       }\r
 122       @feeds.each { |k, f|\r
 123         f.mutex = Mutex.new unless f.mutex\r
 124         f.sanitize_watchers\r
 125         parseRss(f) if f.xml\r
 126       }\r
 127     else\r
 128       @feeds = Hash.new\r
 129     end\r
 130     @watch = Hash.new\r
 131     rewatch_rss\r
 132   end\r
 133 \r
 134   def name\r
 135     "rss"\r
 136   end\r
 137 \r
 138   def watchlist\r
 139     @feeds.select { |h, f| f.watched? }\r
 140   end\r
 141 \r
 142   def cleanup\r
 143     stop_watches\r
 144   end\r
 145 \r
 146   def save\r
 147     unparsed = Hash.new()\r
 148     @feeds.each { |k, f|\r
 149       f.mutex.synchronize do\r
 150         unparsed[k] = f.dup\r
 151       end\r
 152     }\r
 153     @registry[:feeds] = unparsed\r
 154   end\r
 155 \r
 156   def stop_watch(handle)\r
 157     if @watch.has_key?(handle)\r
 158       begin\r
 159         debug "Stopping watch #{handle}"\r
 160         @bot.timer.remove(@watch[handle])\r
 161         @watch.delete(handle)\r
 162       rescue => e\r
 163         report_problem("Failed to stop watch for #{handle}", e, nil)\r
 164       end\r
 165     end\r
 166   end\r
 167 \r
 168   def stop_watches\r
 169     @watch.each_key { |k|\r
 170       stop_watch(k)\r
 171     }\r
 172   end\r
 173 \r
 174   def help(plugin,topic="")\r
 175     case topic\r
 176     when "show"\r
 177       "rss show #{Bold}handle#{Bold} [#{Bold}limit#{Bold}] : show #{Bold}limit#{Bold} (default: 5, max: 15) entries from rss #{Bold}handle#{Bold}; #{Bold}limit#{Bold} can also be in the form a..b, to display a specific range of items"\r
 178     when "list"\r
 179       "rss list [#{Bold}handle#{Bold}] : list all rss feeds (matching #{Bold}handle#{Bold})"\r
 180     when "watched"\r
 181       "rss watched [#{Bold}handle#{Bold}] [in #{Bold}chan#{Bold}]: list all watched rss feeds (matching #{Bold}handle#{Bold}) (in channel #{Bold}chan#{Bold})"\r
 182     when "who", "watches", "who watches"\r
 183       "rss who watches [#{Bold}handle#{Bold}]]: list all watchers for rss feeds (matching #{Bold}handle#{Bold})"\r
 184     when "add"\r
 185       "rss add #{Bold}handle#{Bold} #{Bold}url#{Bold} [#{Bold}type#{Bold}] : add a new rss called #{Bold}handle#{Bold} from url #{Bold}url#{Bold} (of type #{Bold}type#{Bold})"\r
 186     when "change"\r
 187       "rss change #{Bold}what#{Bold} of #{Bold}handle#{Bold} to #{Bold}new#{Bold} : change the #{Underline}handle#{Underline}, #{Underline}url#{Underline}, #{Underline}type#{Underline} or #{Underline}refresh#{Underline} rate of rss called #{Bold}handle#{Bold} to value #{Bold}new#{Bold}"\r
 188     when /^(del(ete)?|rm)$/\r
 189       "rss del(ete)|rm #{Bold}handle#{Bold} : delete rss feed #{Bold}handle#{Bold}"\r
 190     when "replace"\r
 191       "rss replace #{Bold}handle#{Bold} #{Bold}url#{Bold} [#{Bold}type#{Bold}] : try to replace the url of rss called #{Bold}handle#{Bold} with #{Bold}url#{Bold} (of type #{Bold}type#{Bold}); only works if nobody else is watching it"\r
 192     when "forcereplace"\r
 193       "rss forcereplace #{Bold}handle#{Bold} #{Bold}url#{Bold} [#{Bold}type#{Bold}] : replace the url of rss called #{Bold}handle#{Bold} with #{Bold}url#{Bold} (of type #{Bold}type#{Bold})"\r
 194     when "watch"\r
 195       "rss watch #{Bold}handle#{Bold} [#{Bold}url#{Bold} [#{Bold}type#{Bold}]]  [in #{Bold}chan#{Bold}]: watch rss #{Bold}handle#{Bold} for changes (in channel #{Bold}chan#{Bold}); when the other parameters are present, the feed will be created if it doesn't exist yet"\r
 196     when /(un|rm)watch/\r
 197       "rss unwatch|rmwatch #{Bold}handle#{Bold} [in #{Bold}chan#{Bold}]: stop watching rss #{Bold}handle#{Bold} (in channel #{Bold}chan#{Bold}) for changes"\r
 198     when "rewatch"\r
 199       "rss rewatch : restart threads that watch for changes in watched rss"\r
 200     else\r
 201       "manage RSS feeds: rss show|list|watched|add|change|del(ete)|rm|(force)replace|watch|unwatch|rmwatch|rewatch"\r
 202     end\r
 203   end\r
 204 \r
 205   def report_problem(report, e=nil, m=nil)\r
 206     if m && m.respond_to?(:reply)\r
 207       m.reply report\r
 208     else\r
 209       warning report\r
 210     end\r
 211     if e\r
 212       debug e.inspect\r
 213       debug e.backtrace.join("\n") if e.respond_to?(:backtrace)\r
 214     end\r
 215   end\r
 216 \r
 217   def show_rss(m, params)\r
 218     handle = params[:handle]\r
 219     lims = params[:limit].to_s.match(/(\d+)(?:..(\d+))?/)\r
 220     debug lims.to_a.inspect\r
 221     if lims[2]\r
 222       ll = [[lims[1].to_i-1,lims[2].to_i-1].min,  0].max\r
 223       ul = [[lims[1].to_i-1,lims[2].to_i-1].max, 14].min\r
 224       rev = lims[1].to_i > lims[2].to_i\r
 225     else\r
 226       ll = 0\r
 227       ul = [[lims[1].to_i-1, 0].max, 14].min\r
 228       rev = false\r
 229     end\r
 230 \r
 231     feed = @feeds.fetch(handle.downcase, nil)\r
 232     unless feed\r
 233       m.reply "I don't know any feeds named #{handle}"\r
 234       return\r
 235     end\r
 236 \r
 237     m.reply "lemme fetch it..."\r
 238     title = items = nil\r
 239     fetched = fetchRss(feed, m)\r
 240     return unless fetched or feed.xml\r
 241     if not fetched and feed.items\r
 242       m.reply "using old data"\r
 243     else\r
 244       parsed = parseRss(feed, m)\r
 245       m.reply "using old data" unless parsed\r
 246     end\r
 247     return unless feed.items\r
 248     title = feed.title\r
 249     items = feed.items\r
 250 \r
 251     # We sort the feeds in freshness order (newer ones first)\r
 252     items = freshness_sort(items)\r
 253     disp = items[ll..ul]\r
 254     disp.reverse! if rev\r
 255 \r
 256     m.reply "Channel : #{title}"\r
 257     disp.each do |item|\r
 258       printFormattedRss(feed, item, {:places=>[m.replyto],:handle=>nil,:date=>true})\r
 259     end\r
 260   end\r
 261 \r
 262   def itemDate(item,ex=nil)\r
 263     return item.pubDate if item.respond_to?(:pubDate) and item.pubDate\r
 264     return item.date if item.respond_to?(:date) and item.date\r
 265     return ex\r
 266   end\r
 267 \r
 268   def freshness_sort(items)\r
 269     notime = Time.at(0)\r
 270     items.sort { |a, b|\r
 271       itemDate(b, notime) <=> itemDate(a, notime)\r
 272     }\r
 273   end\r
 274 \r
 275   def list_rss(m, params)\r
 276     wanted = params[:handle]\r
 277     reply = String.new\r
 278     @feeds.each { |handle, feed|\r
 279       next if wanted and !handle.match(/#{wanted}/i)\r
 280       reply << "#{feed.handle}: #{feed.url} (in format: #{feed.type ? feed.type : 'default'})"\r
 281       (reply << " refreshing every #{Utils.secs_to_string(feed.refresh_rate)}") if feed.refresh_rate\r
 282       (reply << " (watched)") if feed.watched_by?(m.replyto)\r
 283       reply << "\n"\r
 284     }\r
 285     if reply.empty?\r
 286       reply = "no feeds found"\r
 287       reply << " matching #{wanted}" if wanted\r
 288     end\r
 289     m.reply reply\r
 290   end\r
 291 \r
 292   def watched_rss(m, params)\r
 293     wanted = params[:handle]\r
 294     chan = params[:chan] || m.replyto\r
 295     reply = String.new\r
 296     watchlist.each { |handle, feed|\r
 297       next if wanted and !handle.match(/#{wanted}/i)\r
 298       next unless feed.watched_by?(chan)\r
 299       reply << "#{feed.handle}: #{feed.url} (in format: #{feed.type ? feed.type : 'default'})"\r
 300       (reply << " refreshing every #{Utils.secs_to_string(feed.refresh_rate)}") if feed.refresh_rate\r
 301       reply << "\n"\r
 302     }\r
 303     if reply.empty?\r
 304       reply = "no watched feeds"\r
 305       reply << " matching #{wanted}" if wanted\r
 306     end\r
 307     m.reply reply\r
 308   end\r
 309 \r
 310   def who_watches(m, params)\r
 311     wanted = params[:handle]\r
 312     reply = String.new\r
 313     watchlist.each { |handle, feed|\r
 314       next if wanted and !handle.match(/#{wanted}/i)\r
 315       reply << "#{feed.handle}: #{feed.url} (in format: #{feed.type ? feed.type : 'default'})"\r
 316       (reply << " refreshing every #{Utils.secs_to_string(feed.refresh_rate)}") if feed.refresh_rate\r
 317       reply << ": watched by #{feed.watchers.join(', ')}"\r
 318       reply << "\n"\r
 319     }\r
 320     if reply.empty?\r
 321       reply = "no watched feeds"\r
 322       reply << " matching #{wanted}" if wanted\r
 323     end\r
 324     m.reply reply\r
 325   end\r
 326 \r
 327   def add_rss(m, params, force=false)\r
 328     handle = params[:handle]\r
 329     url = params[:url]\r
 330     unless url.match(/https?/)\r
 331       m.reply "I only deal with feeds from HTTP sources, so I can't use #{url} (maybe you forgot the handle?)"\r
 332       return\r
 333     end\r
 334     type = params[:type]\r
 335     if @feeds.fetch(handle.downcase, nil) && !force\r
 336       m.reply "There is already a feed named #{handle} (URL: #{@feeds[handle.downcase].url})"\r
 337       return\r
 338     end\r
 339     unless url\r
 340       m.reply "You must specify both a handle and an url to add an RSS feed"\r
 341       return\r
 342     end\r
 343     @feeds[handle.downcase] = RssBlob.new(url,handle,type)\r
 344     reply = "Added RSS #{url} named #{handle}"\r
 345     if type\r
 346       reply << " (format: #{type})"\r
 347     end\r
 348     m.reply reply\r
 349     return handle\r
 350   end\r
 351 \r
 352   def change_rss(m, params)\r
 353     handle = params[:handle].downcase\r
 354     feed = @feeds.fetch(handle, nil)\r
 355     unless feed\r
 356       m.reply "No such feed with handle #{handle}"\r
 357       return\r
 358     end\r
 359     case params[:what].intern\r
 360     when :handle\r
 361       new = params[:new].downcase\r
 362       if @feeds.key?(new) and @feeds[new]\r
 363         m.reply "There already is a feed with handle #{new}"\r
 364         return\r
 365       else\r
 366         feed.mutex.synchronize do\r
 367           @feeds[new] = feed\r
 368           @feeds.delete(handle)\r
 369           feed.handle = new\r
 370         end\r
 371         handle = new\r
 372       end\r
 373     when :url\r
 374       new = params[:new]\r
 375       feed.mutex.synchronize do\r
 376         feed.url = new\r
 377       end\r
 378     when :format, :type\r
 379       new = params[:new]\r
 380       new = nil if new == 'default'\r
 381       feed.mutex.synchronize do\r
 382         feed.type = new\r
 383       end\r
 384     when :refresh\r
 385       new = params[:new].to_i\r
 386       new = nil if new == 0\r
 387       feed.mutex.synchronize do\r
 388         feed.refresh_rate = new\r
 389       end\r
 390     else\r
 391       m.reply "Don't know how to change #{params[:what]} for feeds"\r
 392       return\r
 393     end\r
 394     m.reply "Feed changed:"\r
 395     list_rss(m, {:handle => handle})\r
 396   end\r
 397 \r
 398   def del_rss(m, params, pass=false)\r
 399     feed = unwatch_rss(m, params, true)\r
 400     if feed.watched?\r
 401       m.reply "someone else is watching #{feed.handle}, I won't remove it from my list"\r
 402       return\r
 403     end\r
 404     @feeds.delete(feed.handle.downcase)\r
 405     m.okay unless pass\r
 406     return\r
 407   end\r
 408 \r
 409   def replace_rss(m, params)\r
 410     handle = params[:handle]\r
 411     if @feeds.key?(handle.downcase)\r
 412       del_rss(m, {:handle => handle}, true)\r
 413     end\r
 414     if @feeds.key?(handle.downcase)\r
 415       m.reply "can't replace #{feed.handle}"\r
 416     else\r
 417       add_rss(m, params, true)\r
 418     end\r
 419   end\r
 420 \r
 421   def forcereplace_rss(m, params)\r
 422     add_rss(m, params, true)\r
 423   end\r
 424 \r
 425   def watch_rss(m, params)\r
 426     handle = params[:handle]\r
 427     chan = params[:chan] || m.replyto\r
 428     url = params[:url]\r
 429     type = params[:type]\r
 430     if url\r
 431       add_rss(m, params)\r
 432     end\r
 433     feed = @feeds.fetch(handle.downcase, nil)\r
 434     if feed\r
 435       if feed.add_watch(chan)\r
 436         watchRss(feed, m)\r
 437         m.okay\r
 438       else\r
 439         m.reply "Already watching #{feed.handle} in #{chan}"\r
 440       end\r
 441     else\r
 442       m.reply "Couldn't watch feed #{handle} (no such feed found)"\r
 443     end\r
 444   end\r
 445 \r
 446   def unwatch_rss(m, params, pass=false)\r
 447     handle = params[:handle].downcase\r
 448     chan = params[:chan] || m.replyto\r
 449     unless @feeds.has_key?(handle)\r
 450       m.reply("dunno that feed")\r
 451       return\r
 452     end\r
 453     feed = @feeds[handle]\r
 454     if feed.rm_watch(chan)\r
 455       m.reply "#{chan} has been removed from the watchlist for #{feed.handle}"\r
 456     else\r
 457       m.reply("#{chan} wasn't watching #{feed.handle}") unless pass\r
 458     end\r
 459     if !feed.watched?\r
 460       stop_watch(handle)\r
 461     end\r
 462     return feed\r
 463   end\r
 464 \r
 465   def rewatch_rss(m=nil, params=nil)\r
 466     stop_watches\r
 467 \r
 468     # Read watches from list.\r
 469     watchlist.each{ |handle, feed|\r
 470       watchRss(feed, m)\r
 471     }\r
 472     m.okay if m\r
 473   end\r
 474 \r
 475   private\r
 476   def watchRss(feed, m=nil)\r
 477     if @watch.has_key?(feed.handle)\r
 478       report_problem("watcher thread for #{feed.handle} is already running", nil, m)\r
 479       return\r
 480     end\r
 481     status = Hash.new\r
 482     status[:failures] = 0\r
 483     @watch[feed.handle] = @bot.timer.add(0, status) {\r
 484       debug "watcher for #{feed} started"\r
 485       failures = status[:failures]\r
 486       begin\r
 487         debug "fetching #{feed}"\r
 488         oldxml = feed.xml ? feed.xml.dup : nil\r
 489         unless fetchRss(feed)\r
 490           failures += 1\r
 491         else\r
 492           if oldxml and oldxml == feed.xml\r
 493             debug "xml for #{feed} didn't change"\r
 494             failures -= 1 if failures > 0\r
 495           else\r
 496             if not feed.items\r
 497               debug "no previous items in feed #{feed}"\r
 498               parseRss(feed)\r
 499               failures -= 1 if failures > 0\r
 500             else\r
 501               otxt = feed.items.map { |item| item.to_s }\r
 502               unless parseRss(feed)\r
 503                 debug "no items in feed #{feed}"\r
 504                 failures += 1\r
 505               else\r
 506                 debug "Checking if new items are available for #{feed}"\r
 507                 failures -= 1 if failures > 0\r
 508                 dispItems = feed.items.reject { |item|\r
 509                   otxt.include?(item.to_s)\r
 510                 }\r
 511                 if dispItems.length > 0\r
 512                   debug "Found #{dispItems.length} new items in #{feed}"\r
 513                   # When displaying watched feeds, publish them from older to newer\r
 514                   dispItems.reverse.each { |item|\r
 515                     printFormattedRss(feed, item)\r
 516                   }\r
 517                 else\r
 518                   debug "No new items found in #{feed}"\r
 519                 end\r
 520               end\r
 521             end\r
 522           end\r
 523         end\r
 524       rescue Exception => e\r
 525         error "Error watching #{feed}: #{e.inspect}"\r
 526         debug e.backtrace.join("\n")\r
 527         failures += 1\r
 528       end\r
 529 \r
 530       status[:failures] = failures\r
 531 \r
 532       feed.mutex.synchronize do\r
 533         seconds = (feed.refresh_rate || @bot.config['rss.thread_sleep']) * (failures + 1)\r
 534         seconds += seconds * (rand(100)-50)/100\r
 535         debug "watcher for #{feed} going to sleep #{seconds} seconds.."\r
 536         @bot.timer.reschedule(@watch[feed.handle], seconds)\r
 537       end\r
 538     }\r
 539     debug "watcher for #{feed} added"\r
 540   end\r
 541 \r
 542   def printFormattedRss(feed, item, opts=nil)\r
 543     places = feed.watchers\r
 544     handle = "::#{feed.handle}:: "\r
 545     date = String.new\r
 546     if opts\r
 547       places = opts[:places] if opts.key?(:places)\r
 548       handle = opts[:handle].to_s if opts.key?(:handle)\r
 549       if opts.key?(:date) && opts[:date]\r
 550         if item.respond_to?(:pubDate) \r
 551           if item.pubDate.class <= Time\r
 552             date = item.pubDate.strftime("%Y/%m/%d %H.%M.%S")\r
 553           else\r
 554             date = item.pubDate.to_s\r
 555           end\r
 556         elsif  item.respond_to?(:date)\r
 557           if item.date.class <= Time\r
 558             date = item.date.strftime("%Y/%m/%d %H.%M.%S")\r
 559           else\r
 560             date = item.date.to_s\r
 561           end\r
 562         else\r
 563           date = "(no date)"\r
 564         end\r
 565         date += " :: "\r
 566       end\r
 567     end\r
 568     title = "#{Bold}#{item.title.chomp.riphtml}#{Bold}" if item.title\r
 569     desc = item.description.gsub(/\s+/,' ').strip.riphtml if item.description\r
 570     link = item.link.chomp if item.link\r
 571     line1 = nil\r
 572     line2 = nil\r
 573     case feed.type\r
 574     when 'blog'\r
 575       line1 = "#{handle}#{date}#{item.category.content} blogged at #{link}"\r
 576       line2 = "#{handle}#{title} - #{desc}"\r
 577     when 'forum'\r
 578       line1 = "#{handle}#{date}#{title}#{' @ ' if item.title && item.link}#{link}"\r
 579     when 'wiki'\r
 580       line1 = "#{handle}#{date}#{title}#{' @ ' if item.title && item.link}#{link} has been edited by #{item.dc_creator}. #{desc}"\r
 581     when 'gmane'\r
 582       line1 = "#{handle}#{date}Message #{title} sent by #{item.dc_creator}. #{desc}"\r
 583     when 'trac'\r
 584       line1 = "#{handle}#{date}#{title} @ #{link}"\r
 585       unless item.title =~ /^Changeset \[(\d+)\]/\r
 586         line2 = "#{handle}#{date}#{desc}"\r
 587       end\r
 588     else\r
 589       line1 = "#{handle}#{date}#{title}#{' @ ' if item.title && item.link}#{link}"\r
 590     end\r
 591     places.each { |loc|\r
 592       @bot.say loc, line1, :overlong => :truncate\r
 593       next unless line2\r
 594       @bot.say loc, line2, :overlong => :truncate\r
 595     }\r
 596   end\r
 597 \r
 598   def fetchRss(feed, m=nil)\r
 599     begin\r
 600       # Use 60 sec timeout, cause the default is too low\r
 601       xml = @bot.httputil.get_cached(feed.url, 60, 60)\r
 602     rescue URI::InvalidURIError, URI::BadURIError => e\r
 603       report_problem("invalid rss feed #{feed.url}", e, m)\r
 604       return nil\r
 605     rescue => e\r
 606       report_problem("error getting #{feed.url}", e, m)\r
 607       return nil\r
 608     end\r
 609     debug "fetched #{feed}"\r
 610     unless xml\r
 611       report_problem("reading feed #{feed} failed", nil, m)\r
 612       return nil\r
 613     end\r
 614     feed.mutex.synchronize do\r
 615       feed.xml = xml\r
 616     end\r
 617     return true\r
 618   end\r
 619 \r
 620   def parseRss(feed, m=nil)\r
 621     return nil unless feed.xml\r
 622     feed.mutex.synchronize do\r
 623       xml = feed.xml\r
 624       begin\r
 625         ## do validate parse\r
 626         rss = RSS::Parser.parse(xml)\r
 627         debug "parsed #{feed}"\r
 628       rescue RSS::InvalidRSSError\r
 629         ## do non validate parse for invalid RSS 1.0\r
 630         begin\r
 631           rss = RSS::Parser.parse(xml, false)\r
 632         rescue RSS::Error => e\r
 633           report_problem("parsing rss stream failed, whoops =(", e, m)\r
 634           return nil\r
 635         end\r
 636       rescue RSS::Error => e\r
 637         report_problem("parsing rss stream failed, oioi", e, m)\r
 638         return nil\r
 639       rescue => e\r
 640         report_problem("processing error occured, sorry =(", e, m)\r
 641         return nil\r
 642       end\r
 643       items = []\r
 644       if rss.nil?\r
 645         report_problem("#{feed} does not include RSS 1.0 or 0.9x/2.0", nil, m)\r
 646       else\r
 647         begin\r
 648           rss.output_encoding = 'UTF-8'\r
 649         rescue RSS::UnknownConvertMethod => e\r
 650           report_problem("bah! something went wrong =(", e, m)\r
 651           return nil\r
 652         end\r
 653         rss.channel.title ||= "Unknown"\r
 654         title = rss.channel.title\r
 655         rss.items.each do |item|\r
 656           item.title ||= "Unknown"\r
 657           items << item\r
 658         end\r
 659       end\r
 660 \r
 661       if items.empty?\r
 662         report_problem("no items found in the feed, maybe try weed?", e, m)\r
 663         return nil\r
 664       end\r
 665       feed.title = title\r
 666       feed.items = items\r
 667       return true\r
 668     end\r
 669   end\r
 670 end\r
 671 \r
 672 plugin = RSSFeedsPlugin.new\r
 673 \r
 674 plugin.map 'rss show :handle :limit',\r
 675   :action => 'show_rss',\r
 676   :requirements => {:limit => /^\d+(?:\.\.\d+)?$/},\r
 677   :defaults => {:limit => 5}\r
 678 plugin.map 'rss list :handle',\r
 679   :action => 'list_rss',\r
 680   :defaults => {:handle => nil}\r
 681 plugin.map 'rss watched :handle [in :chan]',\r
 682   :action => 'watched_rss',\r
 683   :defaults => {:handle => nil}\r
 684 plugin.map 'rss who watches :handle',\r
 685   :action => 'who_watches',\r
 686   :defaults => {:handle => nil}\r
 687 plugin.map 'rss add :handle :url :type',\r
 688   :action => 'add_rss',\r
 689   :defaults => {:type => nil}\r
 690 plugin.map 'rss change :what of :handle to :new',\r
 691   :action => 'change_rss',\r
 692   :requirements => { :what => /handle|url|format|type|refresh/ }\r
 693 plugin.map 'rss change :what for :handle to :new',\r
 694   :action => 'change_rss',\r
 695   :requirements => { :what => /handle|url|format|type|refesh/ }\r
 696 plugin.map 'rss del :handle',\r
 697   :action => 'del_rss'\r
 698 plugin.map 'rss delete :handle',\r
 699   :action => 'del_rss'\r
 700 plugin.map 'rss rm :handle',\r
 701   :action => 'del_rss'\r
 702 plugin.map 'rss replace :handle :url :type',\r
 703   :action => 'replace_rss',\r
 704   :defaults => {:type => nil}\r
 705 plugin.map 'rss forcereplace :handle :url :type',\r
 706   :action => 'forcereplace_rss',\r
 707   :defaults => {:type => nil}\r
 708 plugin.map 'rss watch :handle :url :type [in :chan]',\r
 709   :action => 'watch_rss',\r
 710   :defaults => {:url => nil, :type => nil}\r
 711 plugin.map 'rss unwatch :handle [in :chan]',\r
 712   :action => 'unwatch_rss'\r
 713 plugin.map 'rss rmwatch :handle [in :chan]',\r
 714   :action => 'unwatch_rss'\r
 715 plugin.map 'rss rewatch',\r
 716   :action => 'rewatch_rss'\r
 717 \r