rbot 0.9.10 → 0.9.12

data/lib/rbot/core/basics.rb

@@ -0,0 +1,214 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: rbot basic management from IRC
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+
+class BasicsModule < CoreBotModule
+
+  Config.register Config::BooleanValue.new('irc.join_after_identify',
+    :default => false, :wizard => true, :requires_restart => true,
+    :desc => "Should the bot wait until its identification is confirmed before joining any channels?")
+
+  def join_channels
+    @bot.config['irc.join_channels'].each { |c|
+      debug "autojoining channel #{c}"
+      if(c =~ /^(\S+)\s+(\S+)$/i)
+        @bot.join $1, $2
+      else
+        @bot.join c if(c)
+      end
+    }
+  end
+
+  def identified
+    join_channels
+  end
+
+  # on connect, we join the default channels unless we have to wait for
+  # identification. Observe that this means the bot may not connect any channels
+  # until the 'identified' method gets delegated
+  def connect
+    join_channels unless @bot.config['irc.join_after_identify']
+  end
+
+  def ctcp_listen(m)
+    who = m.private? ? "me" : m.target
+    case m.ctcp.intern
+    when :PING
+      m.ctcp_reply m.message
+    when :TIME
+      m.ctcp_reply Time.now.to_s
+    end
+  end
+
+  def bot_join(m, param)
+    if param[:pass]
+      @bot.join param[:chan], param[:pass]
+    else
+      @bot.join param[:chan]
+    end
+  end
+
+  def invite(m)
+    if @bot.auth.allow?(:"basics::move::join", m.source, m.source)
+      @bot.join m.channel
+    end
+  end
+
+  def bot_part(m, param)
+    if param[:chan]
+      @bot.part param[:chan]
+    else
+      @bot.part m.target if m.public?
+    end
+  end
+
+  def bot_quit(m, param)
+    @bot.quit param[:msg].to_s
+  end
+
+  def bot_restart(m, param)
+    @bot.restart param[:msg].to_s
+  end
+
+  def bot_hide(m, param)
+    @bot.join 0
+  end
+
+  def bot_say(m, param)
+    @bot.say param[:where], param[:what].to_s
+  end
+
+  def bot_action(m, param)
+    @bot.action param[:where], param[:what].to_s
+  end
+
+  def bot_mode(m, param)
+    @bot.mode param[:where], param[:what], param[:who].join(" ")
+  end
+
+  def bot_ping(m, param)
+    m.reply "pong"
+  end
+
+  def bot_quiet(m, param)
+    if param.has_key?(:where)
+      @bot.set_quiet param[:where].sub(/^here$/, m.target.downcase)
+    else
+      @bot.set_quiet
+    end
+    # Make sense when the commmand is given in private or in a non-quieted
+    # channel
+    m.okay
+  end
+
+  def bot_talk(m, param)
+    if param.has_key?(:where)
+      @bot.reset_quiet param[:where].sub(/^here$/, m.target.downcase)
+    else
+      @bot.reset_quiet
+    end
+    # Make sense when the commmand is given in private or in a non-quieted
+    # channel
+    m.okay
+  end
+
+  def bot_help(m, param)
+    m.reply @bot.help(param[:topic].join(" "))
+  end
+
+  #TODO move these to a "chatback" plugin
+  # when (/^(botsnack|ciggie)$/i)
+  #   @bot.say m.replyto, @lang.get("thanks_X") % m.sourcenick if(m.public?)
+  #   @bot.say m.replyto, @lang.get("thanks") if(m.private?)
+  # when (/^#{Regexp.escape(@bot.nick)}!*$/)
+  #   @bot.say m.replyto, @lang.get("hello_X") % m.sourcenick
+
+  # handle help requests for "core" topics
+  def help(cmd, topic="")
+    case cmd
+    when "quit"
+      _("quit [<message>] => quit IRC with message <message>")
+    when "restart"
+      _("restart => completely stop and restart the bot (including reconnect)")
+    when "join"
+      _("join <channel> [<key>] => join channel <channel> with secret key <key> if specified. #{@bot.myself} also responds to invites if you have the required access level")
+    when "part"
+      _("part <channel> => part channel <channel>")
+    when "hide"
+      _("hide => part all channels")
+    when "say"
+      _("say <channel>|<nick> <message> => say <message> to <channel> or in private message to <nick>")
+    when "action"
+      _("action <channel>|<nick> <message> => does a /me <message> to <channel> or in private message to <nick>")
+    when "quiet"
+      _("quiet [in here|<channel>] => with no arguments, stop speaking in all channels, if \"in here\", stop speaking in this channel, or stop speaking in <channel>")
+    when "talk"
+      _("talk [in here|<channel>] => with no arguments, resume speaking in all channels, if \"in here\", resume speaking in this channel, or resume speaking in <channel>")
+    when "ping"
+      _("ping => replies with a pong")
+    when "mode"
+      _("mode <channel> <mode> <nicks> => set channel modes for <nicks> on <channel> to <mode>")
+    #     when "botsnack"
+    #       return "botsnack => reward #{@bot.myself} for being good"
+    #     when "hello"
+    #       return "hello|hi|hey|yo [#{@bot.myself}] => greet the bot"
+    else
+      _("%{name}: quit, restart, join, part, hide, save, say, action, topic, quiet, talk, ping, mode") % {:name=>name}
+      #, botsnack, hello
+    end
+  end
+end
+
+basics = BasicsModule.new
+
+basics.map "quit *msg",
+  :action => 'bot_quit',
+  :defaults => { :msg => nil },
+  :auth_path => 'quit'
+basics.map "restart *msg",
+  :action => 'bot_restart',
+  :defaults => { :msg => nil },
+  :auth_path => 'quit'
+
+basics.map "quiet [in] [:where]",
+  :action => 'bot_quiet',
+  :auth_path => 'talk::set'
+basics.map "talk [in] [:where]",
+  :action => 'bot_talk',
+  :auth_path => 'talk::set'
+
+basics.map "say :where *what",
+  :action => 'bot_say',
+  :auth_path => 'talk::do'
+basics.map "action :where *what",
+  :action => 'bot_action',
+  :auth_path => 'talk::do'
+basics.map "mode :where :what *who",
+  :action => 'bot_mode',
+  :auth_path => 'talk::do'
+
+basics.map "join :chan :pass", 
+  :action => 'bot_join',
+  :defaults => {:pass => nil},
+  :auth_path => 'move'
+basics.map "part :chan",
+  :action => 'bot_part',
+  :defaults => {:chan => nil},
+  :auth_path => 'move'
+basics.map "hide",
+  :action => 'bot_hide',
+  :auth_path => 'move'
+
+basics.map "ping",
+  :action => 'bot_ping',
+  :auth_path => '!ping!'
+basics.map "help *topic",
+  :action => 'bot_help',
+  :defaults => { :topic => [""] },
+  :auth_path => '!help!'
+
+basics.default_auth('*', false)
+

data/lib/rbot/core/config.rb

@@ -0,0 +1,330 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: rbot config management from IRC
+#
+# Author:: Giuseppe "Oblomov" Bilotta <giuseppe.bilotta@gmail.com>
+
+class ConfigModule < CoreBotModule
+
+  def version_string
+    if $version_timestamp.to_i > 0
+      ago = _(" [%{secs} ago]") % {
+        :secs => Utils.secs_to_string(Time.now.to_i - $version_timestamp.to_i)
+      }
+    else
+      ago = ''
+    end
+    _("I'm a v. %{version}%{ago} rubybot%{copyright}%{url}") % {
+      :version => $version,
+      :ago => ago,
+      :copyright => ", #{Irc::Bot::COPYRIGHT_NOTICE}",
+      :url => " - #{Irc::Bot::SOURCE_URL}"
+    }
+  end
+
+  def save
+    @bot.config.save
+  end
+
+  def handle_list(m, params)
+    modules = []
+    if params[:module]
+      @bot.config.items.each_key do |key|
+        mod, name = key.to_s.split('.')
+        next unless mod == params[:module]
+        modules.push key unless modules.include?(name)
+      end
+      if modules.empty?
+        m.reply _("no such module %{module}") % {:module => params[:module]}
+      else
+        m.reply modules.join(", ")
+      end
+    else
+      @bot.config.items.each_key do |key|
+        name = key.to_s.split('.').first
+        modules.push name unless modules.include?(name)
+      end
+      m.reply "modules: " + modules.join(", ")
+    end
+  end
+
+  def handle_get(m, params)
+    key = params[:key].to_s.intern
+    unless @bot.config.items.has_key?(key)
+      m.reply _("no such config key %{key}") % {:key => key}
+      return
+    end
+    return if !@bot.auth.allow?(@bot.config.items[key].auth_path, m.source, m.replyto)
+    value = @bot.config.items[key].to_s
+    m.reply "#{key}: #{value}"
+  end
+
+  def handle_desc(m, params)
+    key = params[:key].to_s.intern
+    unless @bot.config.items.has_key?(key)
+      m.reply _("no such config key %{key}") % {:key => key}
+    end
+    m.reply "#{key}: #{@bot.config.items[key].desc}"
+  end
+
+  def handle_search(m, params)
+    rx = Regexp.new(params[:rx].to_s, true)
+    cfs = []
+    @bot.config.items.each do |k, v|
+      cfs << [Bold + k.to_s + Bold, v.desc] if k.to_s.match(rx) or (v.desc.match(rx) rescue false)
+    end
+    if cfs.empty?
+      m.reply _("no config key found matching %{r}") % { :r => params[:rx].to_s}
+    else
+      m.reply _("possible keys: %{kl}") % { :kl => cfs.map { |c| c.first}.sort.join(', ') } if cfs.length > 1
+      m.reply cfs.map { |c| c.join(': ') }.join("\n")
+    end
+  end
+
+  def handle_unset(m, params)
+    key = params[:key].to_s.intern
+    unless @bot.config.items.has_key?(key)
+      m.reply _("no such config key %{key}") % {:key => key}
+    end
+    return if !@bot.auth.allow?(@bot.config.items[key].auth_path, m.source, m.replyto)
+    @bot.config.items[key].unset
+    handle_get(m, params)
+    m.reply _("this config change will take effect on the next restart") if @bot.config.items[key].requires_restart
+    m.reply _("this config change will take effect on the next rescan") if @bot.config.items[key].requires_rescan
+  end
+
+  def handle_set(m, params)
+    key = params[:key].to_s.intern
+    value = params[:value].join(" ")
+    unless @bot.config.items.has_key?(key)
+      m.reply _("no such config key %{key}") % {:key => key} unless params[:silent]
+      return false
+    end
+    return false if !@bot.auth.allow?(@bot.config.items[key].auth_path, m.source, m.replyto)
+    begin
+      @bot.config.items[key].set_string(value)
+    rescue ArgumentError => e
+      m.reply _("failed to set %{key}: %{error}") % {:key => key, :error => e.message} unless params[:silent]
+      return false
+    end
+    if @bot.config.items[key].requires_restart
+      m.reply _("this config change will take effect on the next restart") unless params[:silent]
+      return :restart
+    elsif @bot.config.items[key].requires_rescan
+      m.reply _("this config change will take effect on the next rescan") unless params[:silent]
+      return :rescan
+    else
+      m.okay unless params[:silent]
+      return true
+    end
+  end
+
+  def handle_add(m, params)
+    key = params[:key].to_s.intern
+    value = params[:value]
+    unless @bot.config.items.has_key?(key)
+      m.reply _("no such config key %{key}") % {:key => key}
+      return
+    end
+    unless @bot.config.items[key].kind_of?(Config::ArrayValue)
+      m.reply _("config key %{key} is not an array") % {:key => key}
+      return
+    end
+    return if !@bot.auth.allow?(@bot.config.items[key].auth_path, m.source, m.replyto)
+    begin
+      @bot.config.items[key].add(value)
+    rescue ArgumentError => e
+      m.reply _("failed to add %{value} to %{key}: %{error}") % {:value => value, :key => key, :error => e.message}
+      return
+    end
+    handle_get(m,{:key => key})
+    m.reply _("this config change will take effect on the next restart") if @bot.config.items[key].requires_restart
+    m.reply _("this config change will take effect on the next rescan") if @bot.config.items[key].requires_rescan
+  end
+
+  def handle_rm(m, params)
+    key = params[:key].to_s.intern
+    value = params[:value]
+    unless @bot.config.items.has_key?(key)
+      m.reply _("no such config key %{key}") % {:key => key}
+      return
+    end
+    unless @bot.config.items[key].kind_of?(Config::ArrayValue)
+      m.reply _("config key %{key} is not an array") % {:key => key}
+      return
+    end
+    return if !@bot.auth.allow?(@bot.config.items[key].auth_path, m.source, m.replyto)
+    begin
+      @bot.config.items[key].rm(value)
+    rescue ArgumentError => e
+      m.reply _("failed to remove %{value} from %{key}: %{error}") % {:value => value, :key => key, :error => e.message}
+      return
+    end
+    handle_get(m,{:key => key})
+    m.reply _("this config change will take effect on the next restart") if @bot.config.items[key].requires_restart
+    m.reply _("this config change will take effect on the next rescan") if @bot.config.items[key].requires_rescan
+  end
+
+  def bot_save(m, param)
+    @bot.save
+    m.okay
+  end
+
+  def bot_rescan(m, param)
+    m.reply _("saving ...")
+    @bot.save
+    m.reply _("rescanning ...")
+    @bot.rescan
+    m.reply _("done. %{plugin_status}") % {:plugin_status => @bot.plugins.status(true)}
+  end
+
+  def bot_nick(m, param)
+    @bot.nickchg(param[:nick])
+    @bot.wanted_nick = param[:nick]
+  end
+
+  def bot_status(m, param)
+    m.reply @bot.status
+  end
+
+  # TODO is this one of the methods that disappeared when the bot was moved
+  # from the single-file to the multi-file registry?
+  #
+  #  def bot_reg_stat(m, param)
+  #    m.reply @registry.stat.inspect
+  #  end
+
+  def bot_version(m, param)
+    m.reply version_string
+  end
+
+  def ctcp_listen(m)
+    who = m.private? ? "me" : m.target
+    case m.ctcp.intern
+    when :VERSION
+      m.ctcp_reply version_string
+    when :SOURCE
+      m.ctcp_reply Irc::Bot::SOURCE_URL
+    end
+  end
+
+  def handle_help(m, params)
+    m.reply help(params[:topic])
+  end
+
+  def help(plugin, topic="")
+    case plugin
+    when "config"
+      case topic
+      when "list"
+      _("config list => list configuration modules, config list <module> => list configuration keys for module <module>")
+      when "get"
+      _("config get <key> => get configuration value for key <key>")
+      when "unset"
+      _("reset key <key> to the default")
+      when "set"
+      _("config set <key> <value> => set configuration value for key <key> to <value>")
+      when "desc"
+      _("config desc <key> => describe what key <key> configures")
+      when "add"
+      _("config add <value> to <key> => add value <value> to key <key> if <key> is an array")
+      when "rm"
+      _("config rm <value> from <key> => remove value <value> from key <key> if <key> is an array")
+      else
+      _("config module - bot configuration. usage: list, desc, get, set, unset, add, rm")
+      # else
+      #   "no help for config #{topic}"
+      end
+    when "nick"
+      _("nick <newnick> => change the bot nick to <newnick>, if possible")
+    when "status"
+      _("status => display some information on the bot's status")
+    when "save"
+      _("save => save current dynamic data and configuration")
+    when "rescan"
+      _("rescan => reload modules and static facts")
+    when "version"
+      _("version => describes software version")
+    else
+      _("config-related tasks: config, save, rescan, version, nick, status")
+    end
+  end
+
+end
+
+conf = ConfigModule.new
+
+conf.map 'config list :module',
+  :action => 'handle_list',
+  :defaults => {:module => false},
+  :auth_path => 'show'
+# TODO this one is presently a security risk, since the bot
+# stores the master password in the config. Do we need auth levels
+# on the Bot::Config keys too?
+conf.map 'config get :key',
+  :action => 'handle_get',
+  :auth_path => 'show'
+conf.map 'config desc :key',
+  :action => 'handle_desc',
+  :auth_path => 'show'
+conf.map 'config describe :key',
+  :action => 'handle_desc',
+  :auth_path => 'show::desc!'
+conf.map 'config search *rx',
+  :action => 'handle_search',
+  :auth_path => 'show'
+
+conf.map "save",
+  :action => 'bot_save'
+conf.map "rescan",
+  :action => 'bot_rescan'
+conf.map "nick :nick",
+  :action => 'bot_nick'
+conf.map "status",
+  :action => 'bot_status',
+  :auth_path => 'show::status'
+# TODO see above
+#
+# conf.map "registry stats",
+#   :action => 'bot_reg_stat',
+#   :auth_path => '!config::status'
+conf.map "version",
+  :action => 'bot_version',
+  :auth_path => 'show::status'
+
+conf.map 'config set :key *value',
+  :action => 'handle_set',
+  :auth_path => 'edit'
+conf.map 'config add :value to :key',
+  :action => 'handle_add',
+  :auth_path => 'edit'
+conf.map 'config rm :value from :key',
+  :action => 'handle_rm',
+  :auth_path => 'edit'
+conf.map 'config del :value from :key',
+  :action => 'handle_rm',
+  :auth_path => 'edit'
+conf.map 'config delete :value from :key',
+  :action => 'handle_rm',
+  :auth_path => 'edit'
+conf.map 'config unset :key',
+  :action => 'handle_unset',
+  :auth_path => 'edit'
+conf.map 'config reset :key',
+  :action => 'handle_unset',
+  :auth_path => 'edit'
+
+conf.map 'config help :topic',
+  :action => 'handle_help',
+  :defaults => {:topic => false},
+  :auth_path => '!help!'
+
+conf.default_auth('*', false)
+conf.default_auth('show', true)
+conf.default_auth('show::get', false)
+# TODO these shouldn't be set here, we need a way to let the default
+# permission be specified together with the ConfigValue
+conf.default_auth('key', true)
+conf.default_auth('key::auth::password', false)
+