rbot 0.9.10 → 0.9.12

data/data/rbot/templates/levels.rbot

@@ -1,32 +0,0 @@
-100 auth
-90 quit
-90 restart
-85 config
-80 nick
-80 nickserv
-80 qauth
-80 http
-85 autoop
-70 opme
-70 mode
-70 say
-70 action
-40 quiet
-40 talk
-50 part
-50 hide
-50 join
-15 delquote
-12 msginsult
-12 remind_other
-12 markov
-5 rmlart
-5 rmpraise
-5 keycmd
-5 lart
-5 addlart
-5 addpraise
-5 remind
-5 keyword
-5 addquote
-5 getquote

data/data/rbot/templates/users.rbot

@@ -1 +0,0 @@
-10 *!*@*

data/lib/rbot/auth.rb

@@ -1,314 +0,0 @@
-module Irc
-
-  # globmask:: glob to test with
-  # netmask::  netmask to test against
-  # Compare a netmask with a standard IRC glob, e.g foo!bar@baz.com would
-  # match *!*@baz.com, foo!*@*, *!bar@*, etc.
-  def Irc.netmaskmatch( globmask, netmask )
-    regmask = Regexp.escape( globmask )
-    regmask.gsub!( /\\\*/, '.*' )
-    return true if(netmask =~ /#{regmask}/i)
-    return false
-  end
-
-  # check if a string is an actual IRC hostmask
-  def Irc.ismask?(mask)
-    mask =~ /^.+!.+@.+$/
-  end
-
-  Struct.new( 'UserData', :level, :password, :hostmasks )
-
-  # User-level authentication to allow/disallow access to bot commands based
-  # on hostmask and userlevel.
-  class IrcAuth
-    BotConfig.register BotConfigStringValue.new( 'auth.password',
-      :default => 'rbotauth', :wizard => true,
-      :desc => 'Your password for maxing your auth with the bot (used to associate new hostmasks with your owner-status etc)' )
-    BotConfig.register BotConfigIntegerValue.new( 'auth.default_level',
-      :default => 10, :wizard => true,
-      :desc => 'The default level for new/unknown users' )
-
-    # create a new IrcAuth instance.
-    # bot:: associated bot class
-    def initialize(bot)
-      @bot = bot
-      @users = Hash.new do
-        Struct::UserData.new(@bot.config['auth.default_level'], '', [])
-      end
-      @levels = Hash.new(0)
-      @currentUsers = Hash.new( nil )
-      if( File.exist?( "#{@bot.botclass}/users.yaml" ) )
-        File.open( "#{@bot.botclass}/users.yaml" ) { |file|
-          # work around YAML not maintaining the default proc
-          @loadedusers = YAML::parse(file).transform
-          @users.update(@loadedusers)
-        }
-      end
-      if(File.exist?("#{@bot.botclass}/levels.rbot"))
-        IO.foreach("#{@bot.botclass}/levels.rbot") do |line|
-          if(line =~ /\s*(\d+)\s*(\S+)/)
-            level = $1.to_i
-            command = $2
-            @levels[command] = level
-          end
-        end
-      end
-      if @levels.length < 1
-        raise RuntimeError, "No valid levels.rbot found! If you really want a free-for-all bot and this isn't the result of a previous error, write a proper levels.rbot"
-      end
-    end
-
-    # save current users and levels to files.
-    # levels are written to #{botclass}/levels.rbot
-    # users are written to #{botclass}/users.yaml
-    def save
-      Dir.mkdir("#{@bot.botclass}") if(!File.exist?("#{@bot.botclass}"))
-      begin
-        debug "Writing new users.yaml ..."
-        File.open("#{@bot.botclass}/users.yaml.new", 'w') do |file|
-          file.puts @users.to_yaml
-        end
-        debug "Officializing users.yaml ..."
-        File.rename("#{@bot.botclass}/users.yaml.new",
-                    "#{@bot.botclass}/users.yaml")
-      rescue
-        error "failed to write configuration file users.yaml! #{$!}"
-        error "#{e.class}: #{e}"
-        error e.backtrace.join("\n")
-      end
-      begin
-        debug "Writing new levels.rbot ..."
-        File.open("#{@bot.botclass}/levels.rbot.new", 'w') do |file|
-          @levels.each do |key, value|
-            file.puts "#{value} #{key}"
-          end
-        end
-        debug "Officializing levels.rbot ..."
-        File.rename("#{@bot.botclass}/levels.rbot.new",
-                    "#{@bot.botclass}/levels.rbot")
-      rescue
-        error "failed to write configuration file levels.rbot! #{$!}"
-        error "#{e.class}: #{e}"
-        error e.backtrace.join("\n")
-      end
-    end
-
-    # command:: command user wishes to perform
-    # mask::    hostmask of user
-    # tell::    optional recipient for "insufficient auth" message
-    #
-    # returns true if user with hostmask +mask+ is permitted to perform
-    # +command+ optionally pass tell as the target for the "insufficient auth"
-    # message, if the user is not authorised
-    def allow?( command, mask, tell=nil )
-      auth = @users[matchingUser(mask)].level # Directly using @users[] is possible, because UserData has a default setting
-        if( auth >= @levels[command] )
-          return true
-        else
-          debug "#{mask} is not allowed to perform #{command}"
-          @bot.say tell, "insufficient \"#{command}\" auth (have #{auth}, need #{@levels[command]})" if tell
-          return false
-        end
-    end
-
-    # add user with hostmask matching +mask+ with initial auth level +level+
-    def useradd( username, level=@bot.config['auth.default_level'], password='', hostmask='*!*@*' )
-      @users[username] = Struct::UserData.new( level, password, [hostmask] ) if ! @users.has_key? username
-    end
-
-    # mask:: mask of user to remove
-    # remove user with mask +mask+
-    def userdel( username )
-      @users.delete( username ) if @users.has_key? username
-    end
-
-    def usermod( username, item, value=nil )
-      if @users.has_key?( username )
-        case item
-          when 'hostmask'
-            if Irc.ismask?( value )
-              @users[username].hostmasks = [ value ]
-              return true
-            end
-          when '+hostmask'
-            if Irc.ismask?( value )
-              @users[username].hostmasks += [ value ]
-              return true
-            end
-          when '-hostmask'
-            if Irc.ismask?( value )
-              @users[username].hostmasks -= [ value ]
-              return true
-            end
-          when 'password'
-              @users[username].password = value
-              return true
-          when 'level'
-              @users[username].level = value.to_i
-              return true
-          else
-            debug "usermod: Tried to modify unknown item #{item}"
-	    # @bot.say tell, "Unknown item #{item}" if tell
-        end
-      end
-      return false
-    end
-
-    # command:: command to adjust
-    # level::   new auth level for the command
-    # set required auth level of +command+ to +level+
-    def setlevel(command, level)
-      @levels[command] = level
-    end
-
-    def matchingUser( mask )
-      currentUser = nil
-      currentLevel = 0
-      @users.each { |user, data| # TODO Will get easier if YPaths are used...
-        if data.level > currentLevel
-          data.hostmasks.each { |hostmask|
-            if Irc.netmaskmatch( hostmask, mask )
-              currentUser = user
-              currentLevel = data.level
-            end
-          }
-        end
-      }
-      currentUser
-    end
-
-    def identify( mask, username, password )
-      return false unless @users.has_key?(username) && @users[username].password == password
-      @bot.auth.usermod( username, '+hostmask', mask )
-      return true
-    end
-
-    # return all currently defined commands (for which auth is required) and
-    # their required authlevels
-    def showlevels
-      reply = 'Current levels are:'
-      @levels.sort.each { |key, value|
-        reply += " #{key}(#{value})"
-      }
-      reply
-    end
-
-    # return all currently defined users and their authlevels
-    def showusers
-      reply = 'Current users are:'
-      @users.sort.each { |key, value|
-        reply += " #{key}(#{value.level})"
-      }
-      reply
-    end
-
-    def showdetails( username )
-      if @users.has_key? username
-        reply = "#{username}(#{@users[username].level}):"
-        @users[username].hostmasks.each { |hostmask|
-          reply += " #{hostmask}"
-        }
-      end
-      reply
-    end
-
-    # module help
-    def help(topic='')
-      case topic
-        when 'setlevel'
-          return 'setlevel <command> <level> => Sets required level for <command> to <level> (private addressing only)'
-        when 'useradd'
-          return 'useradd <username> => Add user <mask>, you still need to set him up correctly (private addressing only)'
-        when 'userdel'
-          return 'userdel <username> => Remove user <username> (private addressing only)'
-        when 'usermod'
-          return 'usermod <username> <item> <value> => Modify <username>s settings. Valid <item>s are: hostmask, (+|-)hostmask, password, level (private addressing only)'
-        when 'auth'
-          return 'auth <masterpw> => Create a user with your hostmask and master password as bot master (private addressing only)'
-        when 'levels'
-          return 'levels => list commands and their required levels (private addressing only)'
-        when 'users'
-          return 'users [<username>]=> list users and their levels or details about <username> (private addressing only)'
-        when 'whoami'
-          return 'whoami => Show as whom you are recognized (private addressing only)'
-        when 'identify'
-          return 'identify <username> <password> => Identify your hostmask as belonging to <username> (private addressing only)'
-        else
-          return 'Auth module (User authentication) topics: setlevel, useradd, userdel, usermod, auth, levels, users, whoami, identify'
-      end
-    end
-
-    # privmsg handler
-    def privmsg(m)
-     if(m.address? && m.private?)
-      case m.message
-        when (/^setlevel\s+(\S+)\s+(\d+)$/)
-          if( @bot.auth.allow?( 'auth', m.source, m.replyto ) )
-            @bot.auth.setlevel( $1, $2.to_i )
-            m.reply "level for #$1 set to #$2"
-          end
-        when( /^useradd\s+(\S+)/ ) # FIXME Needs review!!! (\s+(\S+)(\s+(\S+)(\s+(\S+))?)?)? Should this part be added to make complete useradds possible?
-          if( @bot.auth.allow?( 'auth', m.source, m.replyto ) )
-            @bot.auth.useradd( $1 )
-            m.reply "added user #$1, please set him up correctly"
-          end
-        when( /^userdel\s+(\S+)/ )
-          if( @bot.auth.allow?( 'auth', m.source, m.replyto ) )
-            @bot.auth.userdel( $1 )
-            m.reply "user #$1 is gone"
-          end
-        when( /^usermod\s+(\S+)\s+(\S+)\s+(\S+)/ )
-          if( @bot.auth.allow?('auth', m.source, m.replyto ) )
-            if( @bot.auth.usermod( $1, $2, $3 ) )
-              m.reply "Set #$2 of #$1 to #$3"
-            else
-              m.reply "Failed to set #$2 of #$1 to #$3"
-            end
-          end
-        when( /^setpassword\s+(\S+)/ )
-	  password = $1
-          user = @bot.auth.matchingUser( m.source )
-          if user
-	    if @bot.auth.usermod(user, 'password', password)
-	      m.reply "Your password has been set to #{password}"
-	    else
-	      m.reply "Couldn't set password"
-	    end
-          else
-            m.reply 'You don\'t belong to any user.'
-          end
-        when (/^auth\s+(\S+)/)
-          if( $1 == @bot.config['auth.password'] )
-            if ! @users.has_key? 'master'
-              @bot.auth.useradd( 'master', 1000, @bot.config['auth.password'], m.source )
-            else
-              @bot.auth.usermod( 'master', '+hostmask', m.source )
-            end
-            m.reply 'Identified, security level maxed out'
-          else
-            m.reply 'Incorrect password'
-          end
-        when( /^identify\s+(\S+)\s+(\S+)/ )
-          if @bot.auth.identify( m.source, $1, $2 )
-            m.reply "Identified as #$1 (#{@users[$1].level})"
-          else
-            m.reply 'Incorrect username/password'
-          end
-        when( 'whoami' )
-          user = @bot.auth.matchingUser( m.source )
-          if user
-            m.reply "I recognize you as #{user} (#{@users[user].level})"
-          else
-            m.reply 'You don\'t belong to any user.'
-          end
-        when( /^users\s+(\S+)/ )
-          m.reply @bot.auth.showdetails( $1 ) if( @bot.auth.allow?( 'auth', m.source, m.replyto ) )
-        when ( 'levels' )
-          m.reply @bot.auth.showlevels if( @bot.auth.allow?( 'config', m.source, m.replyto ) )
-        when ( 'users' )
-          m.reply @bot.auth.showusers if( @bot.auth.allow?( 'users', m.source, m.replyto ) )
-      end
-     end
-    end
-  end
-end

data/lib/rbot/channel.rb

@@ -1,54 +0,0 @@
-module Irc
-
-  # class to store IRC channel data (users, topic, per-channel configurations)
-  class IRCChannel
-    # name of channel
-    attr_reader :name
-
-    # current channel topic
-    attr_reader :topic
-
-    # hash containing users currently in the channel
-    attr_accessor :users
-
-    # if true, bot won't talk in this channel
-    attr_accessor :quiet
-
-    # name:: channel name
-    # create a new IRCChannel
-    def initialize(name)
-      @name = name
-      @users = Hash.new
-      @quiet = false
-      @topic = Topic.new
-    end
-
-    # eg @bot.channels[chan].topic = topic
-    def topic=(name)
-      @topic.name = name
-    end
-
-    # class to store IRC channel topic information
-    class Topic
-      # topic name
-      attr_accessor :name
-
-      # timestamp
-      attr_accessor :timestamp
-
-      # topic set by
-      attr_accessor :by
-
-      def initialize
-        @name = ""
-      end
-
-      # when called like "puts @bots.channels[chan].topic"
-      def to_s
-        @name
-      end
-    end
-
-  end
-
-end

data/lib/rbot/httputil.rb

@@ -1,309 +0,0 @@
-module Irc
-module Utils
-
-require 'resolv'
-require 'net/http'
-require 'net/https'
-Net::HTTP.version_1_2
-
-# class for making http requests easier (mainly for plugins to use)
-# this class can check the bot proxy configuration to determine if a proxy
-# needs to be used, which includes support for per-url proxy configuration.
-class HttpUtil
-    BotConfig.register BotConfigBooleanValue.new('http.use_proxy',
-      :default => false, :desc => "should a proxy be used for HTTP requests?")
-    BotConfig.register BotConfigStringValue.new('http.proxy_uri', :default => false,
-      :desc => "Proxy server to use for HTTP requests (URI, e.g http://proxy.host:port)")
-    BotConfig.register BotConfigStringValue.new('http.proxy_user',
-      :default => nil,
-      :desc => "User for authenticating with the http proxy (if required)")
-    BotConfig.register BotConfigStringValue.new('http.proxy_pass',
-      :default => nil,
-      :desc => "Password for authenticating with the http proxy (if required)")
-    BotConfig.register BotConfigArrayValue.new('http.proxy_include',
-      :default => [],
-      :desc => "List of regexps to check against a URI's hostname/ip to see if we should use the proxy to access this URI. All URIs are proxied by default if the proxy is set, so this is only required to re-include URIs that might have been excluded by the exclude list. e.g. exclude /.*\.foo\.com/, include bar\.foo\.com")
-    BotConfig.register BotConfigArrayValue.new('http.proxy_exclude',
-      :default => [],
-      :desc => "List of regexps to check against a URI's hostname/ip to see if we should use avoid the proxy to access this URI and access it directly")
-    BotConfig.register BotConfigIntegerValue.new('http.max_redir',
-      :default => 5,
-      :desc => "Maximum number of redirections to be used when getting a document")
-    BotConfig.register BotConfigIntegerValue.new('http.expire_time',
-      :default => 60,
-      :desc => "After how many minutes since last use a cached document is considered to be expired")
-    BotConfig.register BotConfigIntegerValue.new('http.max_cache_time',
-      :default => 60*24,
-      :desc => "After how many minutes since first use a cached document is considered to be expired")
-    BotConfig.register BotConfigIntegerValue.new('http.no_expire_cache',
-      :default => false,
-      :desc => "Set this to true if you want the bot to never expire the cached pages")
-
-  def initialize(bot)
-    @bot = bot
-    @cache = Hash.new
-    @headers = {
-      'User-Agent' => "rbot http util #{$version} (http://linuxbrit.co.uk/rbot/)",
-    }
-  end
-
-  # if http_proxy_include or http_proxy_exclude are set, then examine the
-  # uri to see if this is a proxied uri
-  # the in/excludes are a list of regexps, and each regexp is checked against
-  # the server name, and its IP addresses
-  def proxy_required(uri)
-    use_proxy = true
-    if @bot.config["http.proxy_exclude"].empty? && @bot.config["http.proxy_include"].empty?
-      return use_proxy
-    end
-
-    list = [uri.host]
-    begin
-      list.concat Resolv.getaddresses(uri.host)
-    rescue StandardError => err
-      warning "couldn't resolve host uri.host"
-    end
-
-    unless @bot.config["http.proxy_exclude"].empty?
-      re = @bot.config["http.proxy_exclude"].collect{|r| Regexp.new(r)}
-      re.each do |r|
-        list.each do |item|
-          if r.match(item)
-            use_proxy = false
-            break
-          end
-        end
-      end
-    end
-    unless @bot.config["http.proxy_include"].empty?
-      re = @bot.config["http.proxy_include"].collect{|r| Regexp.new(r)}
-      re.each do |r|
-        list.each do |item|
-          if r.match(item)
-            use_proxy = true
-            break
-          end
-        end
-      end
-    end
-    debug "using proxy for uri #{uri}?: #{use_proxy}"
-    return use_proxy
-  end
-
-  # uri:: Uri to create a proxy for
-  #
-  # return a net/http Proxy object, which is configured correctly for
-  # proxying based on the bot's proxy configuration.
-  # This will include per-url proxy configuration based on the bot config
-  # +http_proxy_include/exclude+ options.
-  def get_proxy(uri)
-    proxy = nil
-    proxy_host = nil
-    proxy_port = nil
-    proxy_user = nil
-    proxy_pass = nil
-
-    if @bot.config["http.use_proxy"]
-      if (ENV['http_proxy'])
-        proxy = URI.parse ENV['http_proxy'] rescue nil
-      end
-      if (@bot.config["http.proxy_uri"])
-        proxy = URI.parse @bot.config["http.proxy_uri"] rescue nil
-      end
-      if proxy
-        debug "proxy is set to #{proxy.host} port #{proxy.port}"
-        if proxy_required(uri)
-          proxy_host = proxy.host
-          proxy_port = proxy.port
-          proxy_user = @bot.config["http.proxy_user"]
-          proxy_pass = @bot.config["http.proxy_pass"]
-        end
-      end
-    end
-
-    h = Net::HTTP.new(uri.host, uri.port, proxy_host, proxy_port, proxy_user, proxy_port)
-    h.use_ssl = true if uri.scheme == "https"
-    return h
-  end
-
-  # uri::         uri to query (Uri object)
-  # readtimeout:: timeout for reading the response
-  # opentimeout:: timeout for opening the connection
-  #
-  # simple get request, returns (if possible) response body following redirs
-  # and caching if requested
-  # if a block is given, it yields the urls it gets redirected to
-  # TODO we really need something to implement proper caching
-  def get(uri_or_str, readtimeout=10, opentimeout=5, max_redir=@bot.config["http.max_redir"], cache=false)
-    if uri_or_str.class <= URI
-      uri = uri_or_str
-    else
-      uri = URI.parse(uri_or_str.to_s)
-    end
-
-    proxy = get_proxy(uri)
-    proxy.open_timeout = opentimeout
-    proxy.read_timeout = readtimeout
-
-    begin
-      proxy.start() {|http|
-        yield uri.request_uri() if block_given?
-        resp = http.get(uri.request_uri(), @headers)
-        case resp
-        when Net::HTTPSuccess
-          if cache && !(resp.key?('cache-control') && resp['cache-control']=='must-revalidate')
-            k = uri.to_s
-            @cache[k] = Hash.new
-            @cache[k][:body] = resp.body
-            @cache[k][:last_mod] = Time.httpdate(resp['last-modified']) if resp.key?('last-modified')
-            if resp.key?('date')
-              @cache[k][:first_use] = Time.httpdate(resp['date'])
-              @cache[k][:last_use] = Time.httpdate(resp['date'])
-            else
-              now = Time.new
-              @cache[k][:first_use] = now
-              @cache[k][:last_use] = now
-            end
-            @cache[k][:count] = 1
-          end
-          return resp.body
-        when Net::HTTPRedirection
-          debug "Redirecting #{uri} to #{resp['location']}"
-          yield resp['location'] if block_given?
-          if max_redir > 0
-            return get( URI.parse(resp['location']), readtimeout, opentimeout, max_redir-1, cache)
-          else
-            warning "Max redirection reached, not going to #{resp['location']}"
-          end
-        else
-          debug "HttpUtil.get return code #{resp.code} #{resp.body}"
-        end
-        return nil
-      }
-    rescue StandardError, Timeout::Error => e
-      error "HttpUtil.get exception: #{e.inspect}, while trying to get #{uri}"
-      debug e.backtrace.join("\n")
-    end
-    return nil
-  end
-
-  # just like the above, but only gets the head
-  def head(uri_or_str, readtimeout=10, opentimeout=5, max_redir=@bot.config["http.max_redir"])
-    if uri_or_str.class <= URI
-      uri = uri_or_str
-    else
-      uri = URI.parse(uri_or_str.to_s)
-    end
-
-    proxy = get_proxy(uri)
-    proxy.open_timeout = opentimeout
-    proxy.read_timeout = readtimeout
-
-    begin
-      proxy.start() {|http|
-        yield uri.request_uri() if block_given?
-        resp = http.head(uri.request_uri(), @headers)
-        case resp
-        when Net::HTTPSuccess
-          return resp
-        when Net::HTTPRedirection
-          debug "Redirecting #{uri} to #{resp['location']}"
-          yield resp['location'] if block_given?
-          if max_redir > 0
-            return head( URI.parse(resp['location']), readtimeout, opentimeout, max_redir-1)
-          else
-            warning "Max redirection reached, not going to #{resp['location']}"
-          end
-        else
-          debug "HttpUtil.head return code #{resp.code}"
-        end
-        return nil
-      }
-    rescue StandardError, Timeout::Error => e
-      error "HttpUtil.head exception: #{e.inspect}, while trying to get #{uri}"
-      debug e.backtrace.join("\n")
-    end
-    return nil
-  end
-
-  # gets a page from the cache if it's still (assumed to be) valid
-  # TODO remove stale cached pages, except when called with noexpire=true
-  def get_cached(uri_or_str, readtimeout=10, opentimeout=5,
-                 max_redir=@bot.config['http.max_redir'],
-                 noexpire=@bot.config['http.no_expire_cache'])
-    if uri_or_str.class <= URI
-      uri = uri_or_str
-    else
-      uri = URI.parse(uri_or_str.to_s)
-    end
-
-    k = uri.to_s
-    if !@cache.key?(k)
-      remove_stale_cache unless noexpire
-      return get(uri, readtimeout, opentimeout, max_redir, true)
-    end
-    now = Time.new
-    begin
-      # See if the last-modified header can be used
-      # Assumption: the page was not modified if both the header
-      # and the cached copy have the last-modified value, and it's the same time
-      # If only one of the cached copy and the header have the value, or if the
-      # value is different, we assume that the cached copyis invalid and therefore
-      # get a new one.
-      # On our first try, we tested for last-modified in the webpage first,
-      # and then on the local cache. however, this is stupid (in general),
-      # so we only test for the remote page if the local copy had the header
-      # in the first place.
-      if @cache[k].key?(:last_mod)
-        h = head(uri, readtimeout, opentimeout, max_redir)
-        if h.key?('last-modified')
-          if Time.httpdate(h['last-modified']) == @cache[k][:last_mod]
-            if h.key?('date')
-              @cache[k][:last_use] = Time.httpdate(h['date'])
-            else
-              @cache[k][:last_use] = now
-            end
-            @cache[k][:count] += 1
-            return @cache[k][:body]
-          end
-          remove_stale_cache unless noexpire
-          return get(uri, readtimeout, opentimeout, max_redir, true)
-        end
-        remove_stale_cache unless noexpire
-        return get(uri, readtimeout, opentimeout, max_redir, true)
-      end
-    rescue => e
-      warning "Error #{e.inspect} getting the page #{uri}, using cache"
-      debug e.backtrace.join("\n")
-      return @cache[k][:body]
-    end
-    # If we still haven't returned, we are dealing with a non-redirected document
-    # that doesn't have the last-modified attribute
-    debug "Could not use last-modified attribute for URL #{uri}, guessing cache validity"
-    if noexpire or !expired?(@cache[k], now)
-      @cache[k][:count] += 1
-      @cache[k][:last_use] = now
-      debug "Using cache"
-      return @cache[k][:body]
-    end
-    debug "Cache expired, getting anew"
-    @cache.delete(k)
-    remove_stale_cache unless noexpire
-    return get(uri, readtimeout, opentimeout, max_redir, true)
-  end
-
-  def expired?(hash, time)
-    (time - hash[:last_use] > @bot.config['http.expire_time']*60) or
-    (time - hash[:first_use] > @bot.config['http.max_cache_time']*60)
-  end
-
-  def remove_stale_cache
-    now = Time.new
-    @cache.reject! { |k, val|
-      !val.key?(:last_modified) && expired?(val, now)
-    }
-  end
-
-end
-end
-end