[user/henk/code/ruby/rbot.git] / lib / rbot / botuser.rb

#-- vim:sw=2:et\r
#++\r
# :title: User management\r
#\r
# rbot user management\r
# Author:: Giuseppe Bilotta (giuseppe.bilotta@gmail.com)\r
# Copyright:: Copyright (c) 2006 Giuseppe Bilotta\r
# License:: GPLv2\r
\r
require 'singleton'\r
require 'set'\r
require 'rbot/maskdb'\r
\r
# This would be a good idea if it was failproof, but the truth\r
# is that other methods can indirectly modify the hash. *sigh*\r
#\r
# class AuthNotifyingHash < Hash\r
#   %w(clear default= delete delete_if replace invert\r
#      merge! update rehash reject! replace shift []= store).each { |m|\r
#     class_eval {\r
#       define_method(m) { |*a|\r
#         r = super(*a)\r
#         Irc::Bot::Auth.manager.set_changed\r
#         r\r
#       }\r
#     }\r
#   }\r
# end\r
# \r
\r
module Irc\r
class Bot\r
\r
\r
  # This module contains the actual Authentication stuff\r
  #\r
  module Auth\r
\r
    Config.register Config::StringValue.new( 'auth.password',\r
      :default => 'rbotauth', :wizard => true,\r
      :on_change => Proc.new {|bot, v| bot.auth.botowner.password = v},\r
      :desc => _('Password for the bot owner'))\r
    Config.register Config::BooleanValue.new( 'auth.login_by_mask',\r
      :default => 'true',\r
      :desc => _('Set false to prevent new botusers from logging in without a password when the user netmask is known'))\r
    Config.register Config::BooleanValue.new( 'auth.autologin',\r
      :default => 'true',\r
      :desc => _('Set false to prevent new botusers from recognizing IRC users without a need to manually login'))\r
    Config.register Config::BooleanValue.new( 'auth.autouser',\r
      :default => 'false',\r
      :desc => _('Set true to allow new botusers to be created automatically'))\r
    # Config.register Config::IntegerValue.new( 'auth.default_level',\r
    #   :default => 10, :wizard => true,\r
    #   :desc => 'The default level for new/unknown users' )\r
\r
    # Generate a random password of length _l_\r
    #\r
    def Auth.random_password(l=8)\r
      pwd = ""\r
      l.times do\r
        pwd << (rand(26) + (rand(2) == 0 ? 65 : 97) ).chr\r
      end\r
      return pwd\r
    end\r
\r
\r
    # An Irc::Bot::Auth::Command defines a command by its "path":\r
    #\r
    #   base::command::subcommand::subsubcommand::subsubsubcommand\r
    #\r
    class Command\r
\r
      attr_reader :command, :path\r
\r
      # A method that checks if a given _cmd_ is in a form that can be\r
      # reduced into a canonical command path, and if so, returns it\r
      #\r
      def sanitize_command_path(cmd)\r
        pre = cmd.to_s.downcase.gsub(/^\*?(?:::)?/,"").gsub(/::$/,"")\r
        return pre if pre.empty?\r
        return pre if pre =~ /^\S+(::\S+)*$/\r
        raise TypeError, "#{cmd.inspect} is not a valid command"\r
      end\r
\r
      # Creates a new Command from a given string; you can then access\r
      # the command as a symbol with the :command method and the whole\r
      # path as :path\r
      #\r
      #   Command.new("core::auth::save").path => [:"*", :"core", :"core::auth", :"core::auth::save"]\r
      #\r
      #   Command.new("core::auth::save").command => :"core::auth::save"\r
      #\r
      def initialize(cmd)\r
        cmdpath = sanitize_command_path(cmd).split('::')\r
        seq = cmdpath.inject(["*"]) { |list, cmd|\r
          list << (list.length > 1 ? list.last + "::" : "") + cmd\r
        }\r
        @path = seq.map { |k|\r
          k.to_sym\r
        }\r
        @command = path.last\r
        debug "Created command #{@command.inspect} with path #{@path.pretty_inspect}"\r
      end\r
\r
      # Returs self\r
      def to_irc_auth_command\r
        self\r
      end\r
\r
    end\r
\r
  end\r
\r
end\r
end\r
\r
\r
class String\r
\r
  # Returns an Irc::Bot::Auth::Comand from the receiver\r
  def to_irc_auth_command\r
    Irc::Bot::Auth::Command.new(self)\r
  end\r
\r
end\r
\r
\r
class Symbol\r
\r
  # Returns an Irc::Bot::Auth::Comand from the receiver\r
  def to_irc_auth_command\r
    Irc::Bot::Auth::Command.new(self)\r
  end\r
\r
end\r
\r
\r
module Irc\r
class Bot\r
\r
\r
  module Auth\r
\r
\r
    # This class describes a permission set\r
    class PermissionSet\r
\r
      attr_reader :perm\r
      # Create a new (empty) PermissionSet\r
      #\r
      def initialize\r
        @perm = {}\r
      end\r
\r
      # Inspection simply inspects the internal hash\r
      def inspect\r
        @perm.inspect\r
      end\r
\r
      # Sets the permission for command _cmd_ to _val_,\r
      #\r
      def set_permission(str, val)\r
        cmd = str.to_irc_auth_command\r
        case val\r
        when true, false\r
          @perm[cmd.command] = val\r
        when nil\r
          @perm.delete(cmd.command)\r
        else\r
          raise TypeError, "#{val.inspect} must be true or false" unless [true,false].include?(val)\r
        end\r
      end\r
\r
      # Resets the permission for command _cmd_\r
      #\r
      def reset_permission(cmd)\r
        set_permission(cmd, nil)\r
      end\r
\r
      # Tells if command _cmd_ is permitted. We do this by returning\r
      # the value of the deepest Command#path that matches.\r
      #\r
      def permit?(str)\r
        cmd = str.to_irc_auth_command\r
        allow = nil\r
        cmd.path.reverse.each { |k|\r
          if @perm.has_key?(k)\r
            allow = @perm[k]\r
            break\r
          end\r
        }\r
        return allow\r
      end\r
\r
    end\r
\r
\r
    # This is the error that gets raised when an invalid password is met\r
    #\r
    class InvalidPassword < RuntimeError\r
    end\r
\r
\r
    # This is the basic class for bot users: they have a username, a\r
    # password, a list of netmasks to match against, and a list of\r
    # permissions. A BotUser can be marked as 'transient', usually meaning\r
    # it's not intended for permanent storage. Transient BotUsers have lower\r
    # priority than nontransient ones for autologin purposes.\r
    #\r
    # To initialize a BotUser, you pass a _username_ and an optional\r
    # hash of options. Currently, only two options are recognized:\r
    #\r
    # transient:: true or false, determines if the BotUser is transient or\r
    #             permanent (default is false, permanent BotUser).\r
    #\r
    #             Transient BotUsers are initialized by prepending an\r
    #             asterisk (*) to the username, and appending a sanitized\r
    #             version of the object_id. The username can be empty.\r
    #             A random password is generated.\r
    #\r
    #             Permanent Botusers need the username as is, and no\r
    #             password is generated.\r
    #\r
    # masks::     an array of Netmasks to initialize the NetmaskList. This\r
    #             list is used as-is for permanent BotUsers.\r
    #\r
    #             Transient BotUsers will alter the list elements which are\r
    #             Irc::User by globbing the nick and any initial nonletter\r
    #             part of the ident.\r
    #\r
    #             The masks option is optional for permanent BotUsers, but\r
    #             obligatory (non-empty) for transients.\r
    #\r
    class BotUser\r
\r
      attr_reader :username\r
      attr_reader :password\r
      attr_reader :netmasks\r
      attr_reader :perm\r
      # Please remember to #set_changed() the Auth.manager\r
      # when modifying data\r
      attr_reader :data\r
      attr_writer :login_by_mask\r
      attr_writer :transient\r
\r
      def autologin=(vnew)\r
        vold = @autologin\r
        @autologin = vnew\r
        if vold && !vnew\r
          @netmasks.each { |n| Auth.manager.maskdb.remove(self, n) }\r
        elsif vnew && !vold\r
          @netmasks.each { |n| Auth.manager.maskdb.add(self, n) }\r
        end\r
      end\r
\r
      # Checks if the BotUser is transient\r
      def transient?\r
        @transient\r
      end\r
\r
      # Checks if the BotUser is permanent (not transient)\r
      def permanent?\r
        !@transient\r
      end\r
\r
      # Sets if the BotUser is permanent or not\r
      def permanent=(bool)\r
        @transient=!bool\r
      end\r
\r
      # Make the BotUser permanent\r
      def make_permanent(name)\r
        raise TypError, "permanent already" if permanent?\r
        @username = BotUser.sanitize_username(name)\r
        @transient = false\r
        reset_autologin\r
        reset_password # or not?\r
        @netmasks.dup.each do |m|\r
          delete_netmask(m)\r
          add_netmask(m.generalize)\r
        end\r
      end\r
\r
      # Create a new BotUser with given username\r
      def initialize(username, options={})\r
        opts = {:transient => false}.merge(options)\r
        @transient = opts[:transient]\r
\r
        if @transient\r
          @username = "*"\r
          @username << BotUser.sanitize_username(username) if username and not username.to_s.empty?\r
          @username << BotUser.sanitize_username(object_id)\r
          reset_password\r
          @login_by_mask=true\r
          @autologin=true\r
        else\r
          @username = BotUser.sanitize_username(username)\r
          @password = nil\r
          reset_login_by_mask\r
          reset_autologin\r
        end\r
\r
        @netmasks = NetmaskList.new\r
        if opts.key?(:masks) and opts[:masks]\r
          masks = opts[:masks]\r
          masks = [masks] unless masks.respond_to?(:each)\r
          masks.each { |m|\r
            mask = m.to_irc_netmask\r
            if @transient and User === m\r
              mask.nick = "*"\r
              mask.host = m.host.dup\r
              mask.user = "*" + m.user.sub(/^\w?[^\w]+/,'')\r
            end\r
            add_netmask(mask) unless mask.to_s == "*"\r
          }\r
        end\r
        raise "must provide a usable mask for transient BotUser #{@username}" if @transient and @netmasks.empty?\r
\r
        @perm = {}\r
\r
        # @data = AuthNotifyingHash.new\r
        @data = {}\r
      end\r
\r
      # Inspection\r
      def inspect\r
        str = "<#{self.class}:#{'0x%08x' % self.object_id}"\r
        str << " (transient)" if @transient\r
        str << ":"\r
        str << " @username=#{@username.inspect}"\r
        str << " @netmasks=#{@netmasks.inspect}"\r
        str << " @perm=#{@perm.inspect}"\r
        str << " @login_by_mask=#{@login_by_mask}"\r
        str << " @autologin=#{@autologin}"\r
        if @data.empty?\r
          str << " no data"\r
        else\r
          str << " data for #{@data.keys.join(', ')}"\r
        end\r
        str << ">"\r
      end\r
\r
      # In strings\r
      def to_s\r
        @username\r
      end\r
\r
      # Convert into a hash\r
      def to_hash\r
        {\r
          :username => @username,\r
          :password => @password,\r
          :netmasks => @netmasks,\r
          :perm => @perm,\r
          :login_by_mask => @login_by_mask,\r
          :autologin => @autologin,\r
          :data => @data\r
        }\r
      end\r
\r
      # Do we allow logging in without providing the password?\r
      #\r
      def login_by_mask?\r
        @login_by_mask\r
      end\r
\r
      # Reset the login-by-mask option\r
      #\r
      def reset_login_by_mask\r
        @login_by_mask = Auth.manager.bot.config['auth.login_by_mask'] unless defined?(@login_by_mask)\r
      end\r
\r
      # Reset the autologin option\r
      #\r
      def reset_autologin\r
        @autologin = Auth.manager.bot.config['auth.autologin'] unless defined?(@autologin)\r
      end\r
\r
      # Do we allow automatic logging in?\r
      #\r
      def autologin?\r
        @autologin\r
      end\r
\r
      # Restore from hash\r
      def from_hash(h)\r
        @username = h[:username] if h.has_key?(:username)\r
        @password = h[:password] if h.has_key?(:password)\r
        @login_by_mask = h[:login_by_mask] if h.has_key?(:login_by_mask)\r
        @autologin = h[:autologin] if h.has_key?(:autologin)\r
        if h.has_key?(:netmasks)\r
          @netmasks = h[:netmasks]\r
          @netmasks.each { |n| Auth.manager.maskdb.add(self, n) } if @autologin\r
        end\r
        @perm = h[:perm] if h.has_key?(:perm)\r
        @data.replace(h[:data]) if h.has_key?(:data)\r
      end\r
\r
      # This method sets the password if the proposed new password\r
      # is valid\r
      def password=(pwd=nil)\r
        pass = pwd.to_s\r
        if pass.empty?\r
          reset_password\r
        else\r
          begin\r
            raise InvalidPassword, "#{pass} contains invalid characters" if pass !~ /^[\x21-\x7e]+$/\r
            raise InvalidPassword, "#{pass} too short" if pass.length < 4\r
            @password = pass\r
          rescue InvalidPassword => e\r
            raise e\r
          rescue => e\r
            raise InvalidPassword, "Exception #{e.inspect} while checking #{pass.inspect} (#{pwd.inspect})"\r
          end\r
        end\r
      end\r
\r
      # Resets the password by creating a new onw\r
      def reset_password\r
        @password = Auth.random_password\r
      end\r
\r
      # Sets the permission for command _cmd_ to _val_ on channel _chan_\r
      #\r
      def set_permission(cmd, val, chan="*")\r
        k = chan.to_s.to_sym\r
        @perm[k] = PermissionSet.new unless @perm.has_key?(k)\r
        @perm[k].set_permission(cmd, val)\r
      end\r
\r
      # Resets the permission for command _cmd_ on channel _chan_\r
      #\r
      def reset_permission(cmd, chan ="*")\r
        set_permission(cmd, nil, chan)\r
      end\r
\r
      # Checks if BotUser is allowed to do something on channel _chan_,\r
      # or on all channels if _chan_ is nil\r
      #\r
      def permit?(cmd, chan=nil)\r
        if chan\r
          k = chan.to_s.to_sym\r
        else\r
          k = :*\r
        end\r
        allow = nil\r
        if @perm.has_key?(k)\r
          allow = @perm[k].permit?(cmd)\r
        end\r
        return allow\r
      end\r
\r
      # Adds a Netmask\r
      #\r
      def add_netmask(mask)\r
        m = mask.to_irc_netmask\r
        @netmasks << m\r
        if self.autologin?\r
          Auth.manager.maskdb.add(self, m)\r
          Auth.manager.logout_transients(m) if self.permanent?\r
        end\r
      end\r
\r
      # Removes a Netmask\r
      #\r
      def delete_netmask(mask)\r
        m = mask.to_irc_netmask\r
        @netmasks.delete(m)\r
        Auth.manager.maskdb.remove(self, m) if self.autologin?\r
      end\r
\r
      # This method checks if BotUser has a Netmask that matches _user_\r
      #\r
      def knows?(usr)\r
        user = usr.to_irc_user\r
        !!@netmasks.find { |n| user.matches? n }\r
      end\r
\r
      # This method gets called when User _user_ wants to log in.\r
      # It returns true or false depending on whether the password\r
      # is right. If it is, the Netmask of the user is added to the\r
      # list of acceptable Netmask unless it's already matched.\r
      def login(user, password=nil)\r
        if password == @password or (password.nil? and (@login_by_mask || @autologin) and knows?(user))\r
          add_netmask(user) unless knows?(user)\r
          debug "#{user} logged in as #{self.inspect}"\r
          return true\r
        else\r
          return false\r
        end\r
      end\r
\r
      # # This method gets called when User _user_ has logged out as this BotUser\r
      # def logout(user)\r
      #   delete_netmask(user) if knows?(user)\r
      # end\r
\r
      # This method sanitizes a username by chomping, downcasing\r
      # and replacing any nonalphanumeric character with _\r
      #\r
      def BotUser.sanitize_username(name)\r
        candidate = name.to_s.chomp.downcase.gsub(/[^a-z0-9]/,"_")\r
        raise "sanitized botusername #{candidate} too short" if candidate.length < 3\r
        return candidate\r
      end\r
\r
    end\r
\r
    # This is the default BotUser: it's used for all users which haven't\r
    # identified with the bot\r
    #\r
    class DefaultBotUserClass < BotUser\r
\r
      private :add_netmask, :delete_netmask\r
\r
      include Singleton\r
\r
      # The default BotUser is named 'everyone'\r
      #\r
      def initialize\r
        reset_login_by_mask\r
        reset_autologin\r
        super("everyone")\r
        @default_perm = PermissionSet.new\r
      end\r
\r
      # This method returns without changing anything\r
      #\r
      def login_by_mask=(val)\r
        debug "Tried to change the login-by-mask for default bot user, ignoring"\r
        return @login_by_mask\r
      end\r
\r
      # The default botuser allows logins by mask\r
      #\r
      def reset_login_by_mask\r
        @login_by_mask = true\r
      end\r
\r
      # This method returns without changing anything\r
      #\r
      def autologin=(val)\r
        debug "Tried to change the autologin for default bot user, ignoring"\r
        return\r
      end\r
\r
      # The default botuser doesn't allow autologin (meaningless)\r
      #\r
      def reset_autologin\r
        @autologin = false\r
      end\r
\r
      # Sets the default permission for the default user (i.e. the ones\r
      # set by the BotModule writers) on all channels\r
      #\r
      def set_default_permission(cmd, val)\r
        @default_perm.set_permission(Command.new(cmd), val)\r
        debug "Default permissions now: #{@default_perm.pretty_inspect}"\r
      end\r
\r
      # default knows everybody\r
      #\r
      def knows?(user)\r
        return true if user.to_irc_user\r
      end\r
\r
      # We always allow logging in as the default user\r
      def login(user, password)\r
        return true\r
      end\r
\r
      # DefaultBotUser will check the default_perm after checking\r
      # the global ones\r
      # or on all channels if _chan_ is nil\r
      #\r
      def permit?(cmd, chan=nil)\r
        allow = super(cmd, chan)\r
        if allow.nil? && chan.nil?\r
          allow = @default_perm.permit?(cmd)\r
        end\r
        return allow\r
      end\r
\r
    end\r
\r
    # Returns the only instance of DefaultBotUserClass\r
    #\r
    def Auth.defaultbotuser\r
      return DefaultBotUserClass.instance\r
    end\r
\r
    # This is the BotOwner: he can do everything\r
    #\r
    class BotOwnerClass < BotUser\r
\r
      include Singleton\r
\r
      def initialize\r
        @login_by_mask = false\r
        @autologin = true\r
        super("owner")\r
      end\r
\r
      def permit?(cmd, chan=nil)\r
        return true\r
      end\r
\r
    end\r
\r
    # Returns the only instance of BotOwnerClass\r
    #\r
    def Auth.botowner\r
      return BotOwnerClass.instance\r
    end\r
\r
\r
    # This is the ManagerClass singleton, used to manage\r
    # Irc::User/Irc::Bot::Auth::BotUser connections and everything\r
    #\r
    class ManagerClass\r
\r
      include Singleton\r
\r
      attr_reader :maskdb\r
      attr_reader :everyone\r
      attr_reader :botowner\r
      attr_reader :bot\r
\r
      # The instance manages two <code>Hash</code>es: one that maps\r
      # <code>Irc::User</code>s onto <code>BotUser</code>s, and the other that maps\r
      # usernames onto <code>BotUser</code>\r
      def initialize\r
        @everyone = Auth::defaultbotuser\r
        @botowner = Auth::botowner\r
        bot_associate(nil)\r
      end\r
\r
      def bot_associate(bot)\r
        raise "Cannot associate with a new bot! Save first" if defined?(@has_changes) && @has_changes\r
\r
        reset_hashes\r
\r
        # Associated bot\r
        @bot = bot\r
\r
        # This variable is set to true when there have been changes\r
        # to the botusers list, so that we know when to save\r
        @has_changes = false\r
      end\r
\r
      def set_changed\r
        @has_changes = true\r
      end\r
\r
      def reset_changed\r
        @has_changes = false\r
      end\r
\r
      def changed?\r
        @has_changes\r
      end\r
\r
      # resets the hashes\r
      def reset_hashes\r
        @botusers = Hash.new\r
        @maskdb = NetmaskDb.new\r
        @allbotusers = Hash.new\r
        [everyone, botowner].each do |x|\r
          @allbotusers[x.username.to_sym] = x\r
        end\r
      end\r
\r
      def load_array(ary, forced)\r
        unless ary\r
          warning "Tried to load an empty array"\r
          return\r
        end\r
        raise "Won't load with unsaved changes" if @has_changes and not forced\r
        reset_hashes\r
        ary.each { |x|\r
          raise TypeError, "#{x} should be a Hash" unless x.kind_of?(Hash)\r
          u = x[:username]\r
          unless include?(u)\r
            create_botuser(u)\r
          end\r
          get_botuser(u).from_hash(x)\r
          get_botuser(u).transient = false\r
        }\r
        @has_changes=false\r
      end\r
\r
      def save_array\r
        @allbotusers.values.map { |x|\r
          x.transient? ? nil : x.to_hash\r
        }.compact\r
      end\r
\r
      # checks if we know about a certain BotUser username\r
      def include?(botusername)\r
        @allbotusers.has_key?(botusername.to_sym)\r
      end\r
\r
      # Maps <code>Irc::User</code> to BotUser\r
      def irc_to_botuser(ircuser)\r
        logged = @botusers[ircuser.to_irc_user]\r
        return logged if logged\r
        return autologin(ircuser)\r
      end\r
\r
      # creates a new BotUser\r
      def create_botuser(name, password=nil)\r
        n = BotUser.sanitize_username(name)\r
        k = n.to_sym\r
        raise "botuser #{n} exists" if include?(k)\r
        bu = BotUser.new(n)\r
        bu.password = password\r
        @allbotusers[k] = bu\r
        return bu\r
      end\r
\r
      # returns the botuser with name _name_\r
      def get_botuser(name)\r
        @allbotusers.fetch(BotUser.sanitize_username(name).to_sym)\r
      end\r
\r
      # Logs Irc::User _user_ in to BotUser _botusername_ with password _pwd_\r
      #\r
      # raises an error if _botusername_ is not a known BotUser username\r
      #\r
      # It is possible to autologin by Netmask, on request\r
      #\r
      def login(user, botusername, pwd=nil)\r
        ircuser = user.to_irc_user\r
        n = BotUser.sanitize_username(botusername)\r
        k = n.to_sym\r
        raise "No such BotUser #{n}" unless include?(k)\r
        if @botusers.has_key?(ircuser)\r
          return true if @botusers[ircuser].username == n\r
          # TODO\r
          # @botusers[ircuser].logout(ircuser)\r
        end\r
        bu = @allbotusers[k]\r
        if bu.login(ircuser, pwd)\r
          @botusers[ircuser] = bu\r
          return true\r
        end\r
        return false\r
      end\r
\r
      # Tries to auto-login Irc::User _user_ by looking at the known botusers that allow autologin\r
      # and trying to login without a password\r
      #\r
      def autologin(user)\r
        ircuser = user.to_irc_user\r
        debug "Trying to autologin #{ircuser}"\r
        return @botusers[ircuser] if @botusers.has_key?(ircuser)\r
        bu = maskdb.find(ircuser)\r
        if bu\r
          debug "trying #{bu}"\r
          bu.login(ircuser) or raise '...what?!'\r
          @botusers[ircuser] = bu\r
          return bu\r
        end\r
        # Finally, create a transient if we're set to allow it\r
        if @bot.config['auth.autouser']\r
          bu = create_transient_botuser(ircuser)\r
          @botusers[ircuser] = bu\r
          return bu\r
        end\r
        return everyone\r
      end\r
\r
      # Creates a new transient BotUser associated with Irc::User _user_,\r
      # automatically logging him in. Note that transient botuser creation can\r
      # fail, typically if we don't have the complete user netmask (e.g. for\r
      # messages coming in from a linkbot)\r
      #\r
      def create_transient_botuser(user)\r
        ircuser = user.to_irc_user\r
        bu = everyone\r
        begin\r
          bu = BotUser.new(ircuser, :transient => true, :masks => ircuser)\r
          bu.login(ircuser)\r
        rescue\r
          warning "failed to create transient for #{user}"\r
          error $!\r
        end\r
        return bu\r
      end\r
\r
      # Logs out any Irc::User matching Irc::Netmask _m_ and logged in\r
      # to a transient BotUser\r
      #\r
      def logout_transients(m)\r
        debug "to check: #{@botusers.keys.join ' '}"\r
        @botusers.keys.each do |iu|\r
          debug "checking #{iu.fullform} against #{m.fullform}"\r
          bu = @botusers[iu]\r
          bu.transient? or next\r
          iu.matches?(m) or next\r
          @botusers.delete(iu).autologin = false\r
        end\r
      end\r
\r
      # Makes transient BotUser _user_ into a permanent BotUser\r
      # named _name_; if _user_ is an Irc::User, act on the transient\r
      # BotUser (if any) it's logged in as\r
      #\r
      def make_permanent(user, name)\r
        # TODO merge BotUser instead?\r
        raise "there's already a BotUser called #{name}" if include?(name)\r
\r
        tuser = nil\r
        case user\r
        when String, Irc::User\r
          tuser = irc_to_botuser(user)\r
        when BotUser\r
          tuser = user\r
        else\r
          raise TypeError, "sorry, don't know how to make #{user.class} into a permanent BotUser"\r
        end\r
        return nil unless tuser\r
        raise TypeError, "#{tuser} is not transient" unless tuser.transient?\r
\r
        tuser.make_permanent(name)\r
        @allbotusers[tuser.username.to_sym] = tuser\r
\r
        return tuser\r
      end\r
\r
      # Checks if User _user_ can do _cmd_ on _chan_.\r
      #\r
      # Permission are checked in this order, until a true or false\r
      # is returned:\r
      # * associated BotUser on _chan_\r
      # * associated BotUser on all channels\r
      # * everyone on _chan_\r
      # * everyone on all channels\r
      #\r
      def permit?(user, cmdtxt, channel=nil)\r
        if user.class <= BotUser\r
          botuser = user\r
        else\r
          botuser = irc_to_botuser(user)\r
        end\r
        cmd = cmdtxt.to_irc_auth_command\r
\r
        chan = channel\r
        case chan\r
        when User\r
          chan = "?"\r
        when Channel\r
          chan = chan.name\r
        end\r
\r
        allow = nil\r
\r
        allow = botuser.permit?(cmd, chan) if chan\r
        return allow unless allow.nil?\r
        allow = botuser.permit?(cmd)\r
        return allow unless allow.nil?\r
\r
        unless botuser == everyone\r
          allow = everyone.permit?(cmd, chan) if chan\r
          return allow unless allow.nil?\r
          allow = everyone.permit?(cmd)\r
          return allow unless allow.nil?\r
        end\r
\r
        raise "Could not check permission for user #{user.inspect} to run #{cmdtxt.inspect} on #{chan.inspect}"\r
      end\r
\r
      # Checks if command _cmd_ is allowed to User _user_ on _chan_, optionally\r
      # telling if the user is authorized\r
      #\r
      def allow?(cmdtxt, user, chan=nil)\r
        if permit?(user, cmdtxt, chan)\r
          return true\r
        else\r
          # cmds = cmdtxt.split('::')\r
          # @bot.say chan, "you don't have #{cmds.last} (#{cmds.first}) permissions here" if chan\r
          @bot.say chan, _("%{user}, you don't have '%{command}' permissions here") %\r
                        {:user=>user, :command=>cmdtxt} if chan\r
          return false\r
        end\r
      end\r
\r
    end\r
\r
    # Returns the only instance of ManagerClass\r
    #\r
    def Auth.manager\r
      return ManagerClass.instance\r
    end\r
\r
  end\r
end\r
\r
  class User\r
\r
    # A convenience method to automatically found the botuser\r
    # associated with the receiver\r
    #\r
    def botuser\r
      Irc::Bot::Auth.manager.irc_to_botuser(self)\r
    end\r
\r
    # Bot-specific data can be stored with Irc::Users. This is\r
    # internally obtained by storing data to the associated BotUser,\r
    # but this is a detail plugin writers shouldn't care about.\r
    # bot_data(:key) can be used to retrieve a particular data set.\r
    # This method is intended for data retrieval, and if the retrieved\r
    # data is modified directly there is no guarantee the changes will\r
    # be saved back. Use #set_bot_data() for that.\r
    #\r
    def bot_data(key=nil)\r
      return self.botuser.data if key.nil?\r
      return self.botuser.data[key]\r
    end\r
\r
    # This method is used to store bot-specific data for the receiver.\r
    # If no block is passed, _value_ is stored for the key _key_;\r
    # if a block is passed, it will be called with the previous\r
    # _key_ value as parameter, and its return value will be stored\r
    # as the new value. If _value_ is present in the block form, it\r
    # will be used to initialize _key_ if it's missing\r
    # \r
    def set_bot_data(key,value=nil,&block)\r
      if not block_given?\r
        self.botuser.data[key]=value\r
        Irc::Bot::Auth.manager.set_changed\r
        return value\r
      end\r
      if value and not bot_data.has_key?(key)\r
        set_bot_data(key, value)\r
      end\r
      r = value\r
      begin\r
        r = yield bot_data(key)\r
      ensure\r
        Irc::Bot::Auth.manager.set_changed\r
      end\r
      return r\r
    end\r
  end\r
\r
end\r