X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=data%2Frbot%2Fplugins%2Freaction.rb;h=879b89fa4735b5286d18afb3f3b17b55d9f9b5d4;hb=90656f4203a0a989b6fb110d4a07598dd186b84c;hp=c2230d65a97f944e8a5676e45e7fac2ed3b20743;hpb=5d7f4bcc224023d9b98e1db6be7095e946ccd818;p=user%2Fhenk%2Fcode%2Fruby%2Frbot.git diff --git a/data/rbot/plugins/reaction.rb b/data/rbot/plugins/reaction.rb index c2230d65..879b89fa 100644 --- a/data/rbot/plugins/reaction.rb +++ b/data/rbot/plugins/reaction.rb @@ -69,22 +69,34 @@ class ::Reaction @trigger << Regexp.new(rex, true) else rex.sub!(/^(["'])(.*)\1$/, '\2') - @trigger << Regexp.new(/\b#{Regexp.escape(rex)}\b/ui) + prepend = ( rex =~ /^\w/ ? '(?:\b)' : '') + append = ( rex =~ /\w$/ ? '(?:\b|$)' : '') + @trigger << Regexp.new(/#{prepend}#{Regexp.escape(rex)}#{append}/ui) end end def add_reply(expr, *args) @raw_replies << expr.dup - act = false + act = :reply rex = expr.dup if rex.sub!(/^act:/,'') - act = true + act = :act + elsif rex.sub!(/^(?:cmd|command):/,'') + act = :cmd + elsif rex.sub!(/^ruby:/,'') + act = :ruby end - @replies << Reply.new(self, act ? :act : :reply, rex, *args) + @replies << Reply.new(self, act, rex, *args) make_ranges return @replies.last end + def rm_reply(num) + @replies.delete_at(num-1) + make_ranges + return @raw_replies.delete_at(num-1) + end + def find_reply(expr) @replies[@raw_replies.index(expr)] rescue nil end @@ -139,6 +151,10 @@ class ReactionPlugin < Plugin ADD_SYNTAX = 'react to *trigger with *reply [at :chance chance]' MOVE_SYNTAX = 'reaction move *source to *dest' + # We'd like to use backreferences for the trigger syntax + # but we can't because it will be merged with the Plugin#map() + # regexp + TRIGGER_SYNTAX = /^(?:act:)?(?:!.*?!|\/.*?\/|".*?"|'.*?'|\S+)/ def add_syntax return ADD_SYNTAX @@ -148,13 +164,17 @@ class ReactionPlugin < Plugin return MOVE_SYNTAX end + def trigger_syntax + return TRIGGER_SYNTAX + end + attr :reactions def initialize super if @registry.has_key?(:reactions) @reactions = @registry[:reactions] - raise unless @reactions + raise LoadError, "corrupted reaction database" unless @reactions else @reactions = [] end @@ -185,34 +205,40 @@ class ReactionPlugin < Plugin when :add help(:react) when :remove, :delete, :rm, :del - "reaction #{topic} => removes the reaction to expression " + "reaction #{topic} [] => removes reactions to expression . If (a positive integer) is specified, only remove the n-th reaction, otherwise remove the trigger completely" + when :move + "reaction move to => move all reactions to to the new trigger " when :chance, :chances "reaction chances are expressed either in terms of percentage (like 30%) or in terms of floating point numbers (like 0.3), and are clipped to be " + "between 0 and 1 (i.e. 0% and 100%). A reaction can have multiple replies, each with a different chance; if the total of the chances is less than one, " + "there is a chance that the trigger will not actually cause a reply. Otherwise, the chances express the relative frequency of the replies." when :trigger, :triggers - "reaction triggers can have one of the format: single_word 'multiple words' \"multiple words \" /regular_expression/ !regular_expression!. " + + "reaction triggers can have one of the format: single_word 'multiple words' \"multiple words \" /regular_expression/ !regular_expression!. " + "If prefixed by 'act:' (e.g. act:/(order|command)s/) the bot will only respond if a CTCP ACTION matches the trigger" when :reply, :replies "reaction replies are simply messages that the bot will reply when a trigger is matched. " + - "Replies can be prefixed by 'act:' (e.g. act:goes shopping) to signify that the bot should act instead of saying the message. " + - "Replies can use the %{key} syntax to access one of the following keys: " + - "who (the user that said the trigger), bot (the bot's own nick), " + - "target (the first word following the trigger), what (whatever follows target), " + - "stuff (everything that follows the trigger), match (the actual matched text), " + - "match1, match2, ... (the i-th capture)" + "Replies prefixed by 'act:' (e.g. act:goes shopping) signify that the bot should act instead of saying the message. " + + "Replies prefixed by 'cmd:' or 'command:' (e.g. cmd:lart %{who}) issue a command to the bot. " + + "Replies can use the %{key} syntax to access the following keys: " + + "who (user that said the trigger), bot (bot's own nick), " + + "target (first word following the trigger), what (whatever follows target), " + + "before (everything that precedes the trigger), after, (everything that follows the trigger), " + + "match (matched text), match1, match2, ... (the i-th capture). " + + "Replies prefixed by 'ruby:' (e.g. ruby:m.reply 'Hello ' + subs[:who]) are interpreted as ruby code. " + + "No %{key} substitution is done in this case, use the subs hash in the code instead. " + + "Be warned that creating ruby replies can open unexpected security holes in the bot." when :list "reaction list [n]: lists the n-the page of programmed reactions (30 reactions are listed per page)" when :show "reaction show : list the programmed replies to trigger " else - "reaction topics: add, remove, delete, rm, del, triggers, replies, chance, list, show" + "reaction topics: add, remove, delete, rm, del, move, triggers, replies, chance, list, show" end end def unreplied(m) return unless PrivMessage === m - debug "testing #{m} for reactions" + debug "testing #{m.inspect} for reactions" return if @reactions.empty? candidates = @reactions.map { |react| blob = react === m @@ -244,8 +270,29 @@ class ReactionPlugin < Plugin reply = wanted.pick_reply debug "picked #{reply}" return unless reply - args = reply.apply(subs) - m.__send__(*args) + act, arg = reply.apply(subs) + case act + when :ruby + begin + # no substitutions for ruby code + eval(reply.reply) + rescue Exception => e + error e + end + when :cmd + begin + # Pass the new message back to the bot. + # FIXME Maybe we should do it the alias way, only calling + # @bot.plugins.privmsg() ? + fake_message(@bot.nick+": "+arg, :from => m) + rescue RecurseTooDeep => e + error e + end + when :reply + m.plainreply arg + else + m.__send__(act, arg) + end end def find_reaction(trigger) @@ -254,6 +301,14 @@ class ReactionPlugin < Plugin } end + def can_add?(m, reaction) + return true if reaction.act == :reply + return true if reaction.act == :act + return true if reaction.act == :ruby and @bot.auth.permit?(m.source, "reaction::react::ruby", m.channel) + return true if reaction.act == :cmd and @bot.auth.permit?(m.source, "reaction::react::cmd", m.channel) + return false + end + def handle_add(m, params) trigger = params[:trigger].to_s reply = params[:reply].to_s @@ -265,20 +320,45 @@ class ReactionPlugin < Plugin pct = pct.to_f.clip(0,1) end + new_reaction = false + reaction = find_reaction(trigger) if not reaction reaction = Reaction.new(trigger) @reactions << reaction - m.reply "Ok, I'll start reacting to #{reaction.raw_trigger}" + new_reaction = true end + found = reaction.find_reply(reply) if found - found.pct = pct - found.author = m.sourcenick - found.date = Time.now - found.channel = m.channel + # ruby replies need special permission + if can_add?(m, found) + found.pct = pct + found.author = m.sourcenick + found.date = Time.now + found.channel = m.channel + else + m.reply _("Sorry, you're not allowed to change %{act} replies here") % { + :act => found.act + } + return + end else found = reaction.add_reply(reply, pct, m.sourcenick, Time.now, m.channel) + unless can_add?(m, found) + m.reply _("Sorry, you're not allowed to add %{act} replies here") % { + :act => found.act + } + reaction.rm_reply(reaction.replies.length) + if new_reaction + @reactions.delete(reaction) + end + return + end + end + + if new_reaction + m.reply "Ok, I'll start reacting to #{reaction.raw_trigger}" end m.reply "I'll react to #{reaction.raw_trigger} with #{reaction.raw_replies.last} (#{(reaction.replies.last.pct * 100).to_i}%)" end @@ -301,11 +381,28 @@ class ReactionPlugin < Plugin def handle_rm(m, params) trigger = params[:trigger].to_s + n = params[:n] + n = n.to_i if n debug trigger.inspect found = find_reaction(trigger) + purged = nil if found - @reactions.delete(found) - m.reply "I won't react to #{found.raw_trigger} anymore" + if n + if n < 1 or n > found.replies.length + m.reply "Please specify an index between 1 and #{found.replies.length}" + return + end + purged = found.rm_reply(n) + if found.replies.length == 0 + @reactions.delete(found) + purged = nil + else + purged = " with #{purged}" + end + else + @reactions.delete(found) + end + m.reply "I won't react to #{found.raw_trigger}#{purged} anymore" else m.reply "no reaction programmed for #{trigger}" end @@ -349,14 +446,12 @@ end plugin = ReactionPlugin.new plugin.map plugin.add_syntax, :action => 'handle_add', - :requirements => { :trigger => /^(?:act:)?!.*?!/ } -plugin.map plugin.add_syntax, :action => 'handle_add', - :requirements => { :trigger => /^(?:act:)?\/.*?\// } -plugin.map plugin.add_syntax, :action => 'handle_add', - :requirements => { :trigger => /^(?:act:)?".*?"/ } -plugin.map plugin.add_syntax, :action => 'handle_add', - :requirements => { :trigger => /^(?:act:)?'.*?'/ } -plugin.map plugin.add_syntax.sub('*', ':'), :action => 'handle_add' + :requirements => { :trigger => plugin.trigger_syntax } + +# ruby reactions are security holes, so give stricter permission +plugin.default_auth('react::ruby', false) +# cmd reactions can be security holes too +plugin.default_auth('react::cmd', false) plugin.map 'reaction list [:page]', :action => 'handle_list', :requirements => { :page => /^\d+$/ } @@ -364,16 +459,14 @@ plugin.map 'reaction list [:page]', :action => 'handle_list', plugin.map 'reaction show *trigger', :action => 'handle_show' plugin.map plugin.move_syntax, :action => 'handle_move', - :requirements => { :source => /^(?:act:)?!.*?!/ } -plugin.map plugin.move_syntax, :action => 'handle_move', - :requirements => { :source => /^(?:act:)?\/.*?\// } -plugin.map plugin.move_syntax, :action => 'handle_move', - :requirements => { :source => /^(?:act:)?".*?"/ } -plugin.map plugin.move_syntax, :action => 'handle_move', - :requirements => { :source => /^(?:act:)?'.*?'/ } -plugin.map plugin.move_syntax.sub('*', ':'), :action => 'handle_move' - - -plugin.map 'reaction del[ete] *trigger', :action => 'handle_rm', :auth_path => 'del!' -plugin.map 'reaction remove *trigger', :action => 'handle_rm', :auth_path => 'del!' -plugin.map 'reaction rm *trigger', :action => 'handle_rm', :auth_path => 'del!' + :requirements => { + :source => plugin.trigger_syntax, + :dest => plugin.trigger_syntax + } + +plugin.map 'reaction del[ete] *trigger [:n]', :action => 'handle_rm', :auth_path => 'del!', + :requirements => { :trigger => plugin.trigger_syntax, :n => /^\d+$/ } +plugin.map 'reaction remove *trigger [:n]', :action => 'handle_rm', :auth_path => 'del!', + :requirements => { :trigger => plugin.trigger_syntax, :n => /^\d+$/ } +plugin.map 'reaction rm *trigger [:n]', :action => 'handle_rm', :auth_path => 'del!', + :requirements => { :trigger => plugin.trigger_syntax, :n => /^\d+$/ }