X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=data%2Frbot%2Fplugins%2Ffactoids.rb;h=5f31191b25e0204ecaf267891417f684c905c959;hb=3d8bdf551aebdd4fa7ddb10fa8e824232dd4f82b;hp=59f1a06bbda3a5b253a39b258c0b6f145938d85c;hpb=5cfdc208477c0b97d4c23a8d3bdeba662aad19b8;p=user%2Fhenk%2Fcode%2Fruby%2Frbot.git diff --git a/data/rbot/plugins/factoids.rb b/data/rbot/plugins/factoids.rb index 59f1a06b..5f31191b 100644 --- a/data/rbot/plugins/factoids.rb +++ b/data/rbot/plugins/factoids.rb @@ -9,69 +9,155 @@ # # Store (and retrieve) unstructured one-sentence factoids -class FactoidsPlugin < Plugin - class Factoid - def initialize(hash) - @hash = hash.reject { |k, val| val.nil? or val.empty? rescue false } - raise ArgumentError, "no fact!" unless @hash[:fact] - if String === @hash[:when] - @hash[:when] = Time.parse @hash[:when] - end +class ::Factoid + def initialize(hash) + @hash = hash.reject { |k, val| val.nil? or val.empty? rescue false } + raise ArgumentError, "no fact!" unless @hash[:fact] + if String === @hash[:when] + @hash[:when] = Time.parse @hash[:when] end + end - def to_s - @hash[:fact] + def to_s(opts={}) + show_meta = opts[:meta] + fact = @hash[:fact] + if !show_meta + return fact end - - def [](*args) - @hash[*args] + meta = "" + metadata = [] + if @hash[:who] + metadata << _("from %{who}" % @hash) end - - def to_hsh - return @hash + if @hash[:when] + metadata << _("on %{when}" % @hash) end - alias :to_hash :to_hsh + if @hash[:where] + metadata << _("in %{where}" % @hash) + end + unless metadata.empty? + meta << _(" [%{data}]" % {:data => metadata.join(" ")}) + end + return fact+meta end - class FactoidList < ArrayOf - def initialize(ar=[]) - super(Factoid, ar) - end + def [](*args) + @hash[*args] + end - def index(f) - fact = f.to_s - return if fact.empty? - self.map { |f| f[:fact] }.index(fact) - end + def []=(*args) + @hash.send(:[]=,*args) + end - def delete(f) - idx = index(f) - return unless idx - self.delete_at(idx) - end + def to_hsh + return @hash + end + alias :to_hash :to_hsh +end - def grep(x) - self.find_all { |f| - x === f[:fact] - } - end +class ::FactoidList < ArrayOf + def initialize(ar=[]) + super(Factoid, ar) + end + + def index(f) + fact = f.to_s + return if fact.empty? + self.map { |fs| fs[:fact] }.index(fact) + end + + def delete(f) + idx = index(f) + return unless idx + self.delete_at(idx) end + def grep(x) + self.find_all { |f| + x === f[:fact] + } + end +end + +class FactoidsPlugin < Plugin + # TODO default should be language-specific + Config.register Config::ArrayValue.new('factoids.trigger_pattern', + :default => [ + "(this|that|a|the|an|all|both)\\s+(.*)\\s+(is|are|has|have|does|do)\\s+.*:2", + "(this|that|a|the|an|all|both)\\s+(.*?)\\s+(is|are|has|have|does|do)\\s+.*:2", + "(.*)\\s+(is|are|has|have|does|do)\\s+.*", + "(.*?)\\s+(is|are|has|have|does|do)\\s+.*", + ], + :on_change => Proc.new { |bot, v| bot.plugins['factoids'].reset_triggers }, + :desc => "A list of regular expressions matching factoids where keywords can be identified. append ':n' if the keyword is defined by the n-th group instead of the first. if the list is empty, any word will be considered a keyword") + Config.register Config::ArrayValue.new('factoids.not_triggers', + :default => [ + "this","that","the","a","right","who","what","why" + ], + :on_change => Proc.new { |bot, v| bot.plugins['factoids'].reset_triggers }, + :desc => "A list of words that won't be set as keywords") + Config.register Config::BooleanValue.new('factoids.address', + :default => true, + :desc => "Should the bot reply with relevant factoids only when addressed with a direct question? If not, the bot will attempt to lookup foo if someone says 'foo?' in channel") + Config.register Config::ArrayValue.new('factoids.learn_pattern', + :default => [ + ".*\\s+(is|are|has|have)\\s+.*" + ], + :on_change => Proc.new { |bot, v| bot.plugins['factoids'].reset_learn_patterns }, + :desc => "A list of regular expressions matching factoids that the bot can learn. append ':n' if the factoid is defined by the n-th group instead of the whole match.") + Config.register Config::BooleanValue.new('factoids.listen_and_learn', + :default => false, + :desc => "Should the bot learn factoids from what is being said in chat? if true, phrases matching patterns in factoids.learn_pattern will tell the bot when a phrase can be learned") + Config.register Config::BooleanValue.new('factoids.silent_listen_and_learn', + :default => true, + :desc => "Should the bot be silent about the factoids he learns from the chat? If true, the bot will not declare what he learned every time he learns something from factoids.listen_and_learn being true") + Config.register Config::IntegerValue.new('factoids.search_results', + :default => 5, + :desc => "How many factoids to display at a time") + def initialize super - # TODO config - @dir = File.join(@bot.botclass,"factoids") - @filename = "factoids.rbot" - @factoids = FactoidList.new - read_factfile - @changed = false + @triggers = Set.new + @learn_patterns = [] + + @factoids = @registry[:factoids] + unless @factoids + @factoids = FactoidList.new + + @dir = datafile + @filename = "factoids.rbot" + debug "migrate from existing factoids #{@dir}/#{@filename}" + reset_learn_patterns + begin + read_factfile + rescue + debug $! + end + @changed = true + else + reset_learn_patterns + reset_triggers + @changed = false + end end def read_factfile(name=@filename,dir=@dir) fname = File.join(dir,name) + + expf = File.expand_path(fname) + expd = File.expand_path(dir) + raise ArgumentError, _("%{name} (%{fname}) must be under %{dir}" % { + :name => name, + :fname => expf, + :dir => dir + }) unless expf.index(expd) == 0 + if File.exist?(fname) + raise ArgumentError, _("%{name} is not a file" % { + :name => name + }) unless File.file?(fname) factoids = File.readlines(fname) return if factoids.empty? firstline = factoids.shift @@ -83,31 +169,107 @@ class FactoidsPlugin < Plugin } else pattern.map! { |p| p.intern } - raise ArgumentError, "fact must be the last field" unless pattern.last == :fact + raise ArgumentError, _("fact must be the last field") unless pattern.last == :fact factoids.each { |f| ar = f.chomp.split(" | ", pattern.length) @factoids << Factoid.new(Hash[*([pattern, ar].transpose.flatten)]) } end + else + raise ArgumentError, _("%{name} (%{fname}) doesn't exist" % { + :name => name, + :fname => fname + }) end + reset_triggers end def save return unless @changed - Dir.mkdir(@dir) unless FileTest.directory?(@dir) - fname = File.join(@dir,@filename) - ar = ["when | who | where | fact"] - @factoids.each { |f| - ar << "%s | %s | %s | %s" % [ f[:when], f[:who], f[:where], f[:fact]] + @registry[:factoids] = @factoids + @registry.flush + @changed = false + end + + def trigger_patterns_to_rx + return [] if @bot.config['factoids.trigger_pattern'].empty? + @bot.config['factoids.trigger_pattern'].inject([]) { |list, str| + s = str.dup + if s =~ /:(\d+)$/ + idx = $1.to_i + s.sub!(/:\d+$/,'') + else + idx = 1 + end + list << [/^#{s}$/iu, idx] + } + end + + def learn_patterns_to_rx + return [] if @bot.config['factoids.learn_pattern'].empty? + @bot.config['factoids.learn_pattern'].inject([]) { |list, str| + s = str.dup + if s =~ /:(\d+)$/ + idx = $1.to_i + s.sub!(/:\d+$/,'') + else + idx = 0 + end + list << [/^#{s}$/iu, idx] } - Utils.safe_save(fname) do |file| - file.puts ar + end + + def parse_for_trigger(f, rx=nil) + if !rx + regs = trigger_patterns_to_rx + else + regs = rx end - @changed = false + if regs.empty? + f.to_s.scan(/\w+/u) + else + regs.inject([]) { |list, a| + r = a.first + i = a.last + m = r.match(f.to_s) + if m + list << m[i].downcase + else + list + end + } + end + end + + def reset_triggers + return unless @factoids + start_time = Time.now + rx = trigger_patterns_to_rx + triggers = @factoids.inject(Set.new) { |set, f| + found = parse_for_trigger(f, rx) + if found.empty? + set + else + set | found + end + } + debug "Triggers done in #{Time.now - start_time}" + @triggers.replace(triggers - @bot.config['factoids.not_triggers']) + end + + def reset_learn_patterns + @learn_patterns.replace(learn_patterns_to_rx) end def help(plugin, topic="") - _("factoids plugin: learn that , forget that , facts about ") + case plugin + when 'learn' + _("learn that => learn a factoid") + when 'forget' + _("forget fact <#num> => forget factoid number #num ; forget about => forget a factoid") + else + _("factoids plugin: learn that , forget that , facts about ") + end end def learn(m, params) @@ -117,35 +279,135 @@ class FactoidsPlugin < Plugin :who => m.source.fullform, :where => m.channel.to_s ) - if @factoids.index(factoid) - m.reply _("I already know that %{factoid}" % { :factoid => factoid }) + if idx = @factoids.index(factoid) + m.reply _("I already know that %{factoid} [#%{idx}]" % { + :factoid => factoid, + :idx => idx + }) unless params[:silent] else @factoids << factoid @changed = true - m.okay + m.reply _("okay, learned fact #%{num}: %{fact}" % { :num => @factoids.length, :fact => @factoids.last}) unless params[:silent] + trigs = parse_for_trigger(factoid) + @triggers |= trigs unless trigs.empty? end end def forget(m, params) - factoid = params[:stuff].to_s - if @factoids.delete(factoid) - @changed = true - m.okay + if params[:index] + idx = params[:index].scan(/\d+/).first.to_i + total = @factoids.length + if idx <= 0 or idx > total + m.reply _("please select a fact number between 1 and %{total}" % { :total => total }) + return + end + if factoid = @factoids.delete_at(idx-1) + m.reply _("I forgot that %{factoid}" % { :factoid => factoid }) + @changed = true + else + m.reply _("I couldn't delete factoid %{idx}" % { :idx => idx }) + end else - m.reply _("I didn't know that %{factoid}" % { :factoid => factoid }) + factoid = params[:stuff].to_s + if @factoids.delete(factoid) + @changed = true + m.okay + else + m.reply _("I didn't know that %{factoid}" % { :factoid => factoid }) + end end end + def short_fact(fact,index=nil,total=@factoids.length) + idx = index || @factoids.index(fact)+1 + _("[%{idx}/%{total}] %{fact}" % { + :idx => idx, + :total => total, + :fact => fact.to_s(:meta => false) + }) + end + + def long_fact(fact,index=nil,total=@factoids.length) + idx = index || @factoids.index(fact)+1 + _("fact #%{idx} of %{total}: %{fact}" % { + :idx => idx, + :total => total, + :fact => fact.to_s(:meta => true) + }) + end + + def words2rx(words) + # When looking for words we separate them with + # arbitrary whitespace, not whatever they came with + pre = words.map { |w| Regexp.escape(w)}.join("\\s+") + pre << '\b' if pre.match(/\b$/) + pre = '\b' + pre if pre.match(/^\b/) + return Regexp.new(pre, true) + end + def facts(m, params) - if params[:words].empty? - m.reply _("I know %{count} facts" % { :count => @factoids.length }) + total = @factoids.length + if params[:words].nil_or_empty? and params[:rx].nil_or_empty? + m.reply _("I know %{total} facts" % { :total => total }) else - rx = Regexp.new(params[:words].to_s, true) + unless params.key? :words and not params[:words].empty? + rx = Regexp.new(params[:rx].to_s, true) + else + rx = words2rx(params[:words]) + end known = @factoids.grep(rx) + reply = [] if known.empty? - m.reply _("I know nothing about %{words}" % params) + if params.key? :words + reply << _("I know nothing about %{words}" % params) + else params.key? :rx + reply << _("I know nothing matching %{rx}" % params) + end else - m.reply known.join(" | "), :split_at => /\s+\|\s+/ + max_facts = @bot.config['factoids.search_results'] + len = known.length + if len > max_facts + m.reply _("%{len} out of %{total} facts refer to %{words}, I'll only show %{max}" % { + :len => len, + :total => total, + :words => params[:words].to_s, + :max => max_facts + }) + while known.length > max_facts + known.delete_one + end + end + known.each { |f| + reply << short_fact(f) + } + end + m.reply reply.join(". "), :split_at => /\[\d+\/\d+\] /, :purge_split => false + end + end + + def unreplied(m) + if m.message =~ /^(.*)\?\s*$/ + return if @bot.config['factoids.address'] and !m.address? + return if @factoids.empty? + return if @triggers.empty? + query = $1.strip.downcase + if @triggers.include?(query) + words = query.split + words.instance_variable_set(:@string_value, query) + def words.to_s + @string_value + end + facts(m, :words => words) + end + else + return if m.address? # we don't learn stuff directed at us which is not an explicit learn command + return if !@bot.config['factoids.listen_and_learn'] or @learn_patterns.empty? + @learn_patterns.each do |pat, i| + g = pat.match(m.message) + if g and g[i] + learn(m, :stuff => g[i], :silent => @bot.config['factoids.silent_listen_and_learn']) + break + end end end end @@ -170,7 +432,7 @@ class FactoidsPlugin < Plugin end known = @factoids else - rx = Regexp.new(params[:words].to_s, true) + rx = words2rx(params[:words]) known = @factoids.grep(rx) if known.empty? m.reply _("I know nothing about %{words}" % params) @@ -180,26 +442,64 @@ class FactoidsPlugin < Plugin fact = known.pick_one idx = @factoids.index(fact)+1 end - meta = nil - metadata = [] - if fact[:who] - metadata << _("from %{who}" % fact.to_hash) - end - if fact[:when] - metadata << _("on %{when}" % fact.to_hash) + m.reply long_fact(fact, idx, total) + end + + def edit_fact(m, params) + fact = nil + idx = 0 + total = @factoids.length + idx = params[:index].scan(/\d+/).first.to_i + if idx <= 0 or idx > total + m.reply _("please select a fact number between 1 and %{total}" % { :total => total }) + return end - if fact[:where] - metadata << _("in %{where}" % fact.to_hash) + fact = @factoids[idx-1] + begin + if params[:who] + who = params[:who].to_s.sub(/^me$/, m.source.fullform) + fact[:who] = who + @changed = true + end + if params[:when] + dstr = params[:when].to_s + begin + fact[:when] = Time.parse(dstr, "") + @changed = true + rescue + raise ArgumentError, _("not a date '%{dstr}'" % { :dstr => dstr }) + end + end + if params[:where] + fact[:where] = params[:where].to_s + @changed = true + end + rescue Exception + m.reply _("couldn't change learn data for fact %{fact}: %{err}" % { + :fact => fact, + :err => $! + }) + return end - unless metadata.empty? - meta = _(" [learnt %{data}]" % {:data => metadata.join(" ")}) + m.okay + end + + def import(m, params) + fname = params[:filename].to_s + oldlen = @factoids.length + begin + read_factfile(fname) + rescue + m.reply _("failed to import facts from %{fname}: %{err}" % { + :fname => fname, + :err => $! + }) end - m.reply _("fact #%{idx} of %{total}: %{fact}%{meta}" % { - :idx => idx, - :total => total, - :fact => fact, - :meta => meta + m.reply _("%{len} facts loaded from %{fname}" % { + :fname => fname, + :len => @factoids.length - oldlen }) + @changed = true end end @@ -207,9 +507,18 @@ end plugin = FactoidsPlugin.new plugin.default_auth('edit', false) +plugin.default_auth('import', false) plugin.map 'learn that *stuff' plugin.map 'forget that *stuff', :auth_path => 'edit' +plugin.map 'forget fact :index', :requirements => { :index => /^#?\d+$/ }, :auth_path => 'edit' plugin.map 'facts [about *words]' +plugin.map 'facts search *rx' plugin.map 'fact [about *words]' -plugin.map 'fact :index', :requirements => { :index => /#?\d+/ } +plugin.map 'fact :index', :requirements => { :index => /^#?\d+$/ } + +plugin.map 'fact :index :learn from *who', :action => :edit_fact, :requirements => { :learn => /^((?:is|was)\s+)?learn(ed|t)$/, :index => /^#?\d+$/ }, :auth_path => 'edit' +plugin.map 'fact :index :learn on *when', :action => :edit_fact, :requirements => { :learn => /^((?:is|was)\s+)?learn(ed|t)$/, :index => /^#?\d+$/ }, :auth_path => 'edit' +plugin.map 'fact :index :learn in *where', :action => :edit_fact, :requirements => { :learn => /^((?:is|was)\s+)?learn(ed|t)$/, :index => /^#?\d+$/ }, :auth_path => 'edit' + +plugin.map 'facts import [from] *filename', :action => :import, :auth_path => 'import'