rbot 0.9.10 → 0.9.12

data/lib/rbot/config-compat.rb

@@ -0,0 +1,23 @@
+#-- vim:sw=2:et
+#++
+# :title: Config namespace backwards compatibility
+#
+# The move of everything rbot-related to the Irc::Bot::* namespace from Irc::*
+# would cause off-repo plugins to fail if they register any configuration key,
+# so we have to handle this case.
+#
+# Author:: Giuseppe Bilotta (giuseppe.bilotta@gmail.com)
+
+module Irc
+  Config = Bot::Config
+  module BotConfig
+    def BotConfig.register(*args)
+      warn "deprecated usage: please use Irc::Bot::Config instead of Irc::BotConfig (e.g. Config.register instead of BotConfig.register, Config::<type>Value instead of BotConfig<type>Value"
+      Bot::Config.register(*args)
+    end
+  end
+
+  Bot::Config.constants.each { |c|
+    Irc.module_eval("BotConfig#{c} = Bot::Config::#{c}")
+  }
+end

data/lib/rbot/config.rb

@@ -1,19 +1,23 @@
-module Irc
+require 'singleton'
 
-  require 'yaml'
-  require 'rbot/messagemapper'
+require 'yaml'
 
-  unless YAML.respond_to?(:load_file)
-      def YAML.load_file( filepath )
-        File.open( filepath ) do |f|
-          YAML::load( f )
-        end
-      end
+unless YAML.respond_to?(:load_file)
+  def YAML.load_file( filepath )
+    File.open( filepath ) do |f|
+      YAML::load( f )
+    end
   end
+end
+
+
+module Irc
 
-  class BotConfigValue
+class Bot
+module Config
+  class Value
     # allow the definition order to be preserved so that sorting by
-    # definition order is possible. The BotConfigWizard does this to allow
+    # definition order is possible. The Wizard does this to allow
     # the :wizard questions to be in a sensible order.
     @@order = 0
     attr_reader :type
@@ -21,8 +25,12 @@ module Irc
     attr_reader :key
     attr_reader :wizard
     attr_reader :requires_restart
+    attr_reader :requires_rescan
     attr_reader :order
+    attr_reader :manager
+    attr_reader :auth_path
     def initialize(key, params)
+      @manager = Config.manager
       # Keys must be in the form 'module.name'.
       # They will be internally passed around as symbols,
       # but we accept them both in string and symbol form.
@@ -31,8 +39,10 @@ module Irc
       end
       @order = @@order
       @@order += 1
-      @key = key.intern
-      if params.has_key? :default
+      @key = key.to_sym
+      if @manager.overrides.key?(@key)
+        @default = @manager.overrides[@key]
+      elsif params.has_key? :default
         @default = params[:default]
       else
         @default = false
@@ -43,6 +53,8 @@ module Irc
       @validate = params[:validate]
       @wizard = params[:wizard]
       @requires_restart = params[:requires_restart]
+      @requires_rescan = params[:requires_rescan]
+      @auth_path = "config::key::#{key.sub('.','::')}"
     end
     def default
       if @default.instance_of?(Proc)
@@ -52,16 +64,21 @@ module Irc
       end
     end
     def get
-      return BotConfig.config[@key] if BotConfig.config.has_key?(@key)
-      return @default
+      return @manager.config[@key] if @manager.config.has_key?(@key)
+      return default
     end
     alias :value :get
     def set(value, on_change = true)
-      BotConfig.config[@key] = value
-      @on_change.call(BotConfig.bot, value) if on_change && @on_change
+      @manager.config[@key] = value
+      @manager.changed = true
+      @on_change.call(@manager.bot, value) if on_change && @on_change
+      return self
     end
     def unset
-      BotConfig.config.delete(@key)
+      @manager.config.delete(@key)
+      @manager.changed = true
+      @on_change.call(@manager.bot, value) if @on_change
+      return self
     end
 
     # set string will raise ArgumentErrors on failed parse/validate
@@ -73,7 +90,7 @@ module Irc
         raise ArgumentError, "invalid value: #{string}"
       end
     end
-    
+
     # override this. the default will work for strings only
     def parse(string)
       string
@@ -83,42 +100,81 @@ module Irc
       get.to_s
     end
 
-    private
-    def validate(value)
-      return true unless @validate
-      if @validate.instance_of?(Proc)
-        return @validate.call(value)
-      elsif @validate.instance_of?(Regexp)
-        raise ArgumentError, "validation via Regexp only supported for strings!" unless value.instance_of? String
-        return @validate.match(value)
+    protected
+    def validate(val, validator  = @validate)
+      case validator
+      when false, nil
+        return true
+      when Proc
+        return validator.call(val)
+      when Regexp
+        raise ArgumentError, "validation via Regexp only supported for strings!" unless String === val
+        return validator.match(val)
       else
-        raise ArgumentError, "validation type #{@validate.class} not supported"
+        raise ArgumentError, "validation type #{validator.class} not supported"
       end
     end
   end
 
-  class BotConfigStringValue < BotConfigValue
+  class StringValue < Value
   end
-  class BotConfigBooleanValue < BotConfigValue
+
+  class BooleanValue < Value
     def parse(string)
       return true if string == "true"
       return false if string == "false"
-      raise ArgumentError, "#{string} does not match either 'true' or 'false'"
+      if string =~ /^-?\d+$/
+        return string.to_i != 0
+      end
+      raise ArgumentError, "#{string} does not match either 'true' or 'false', and it's not an integer either"
+    end
+    def get
+      r = super
+      if r.kind_of?(Integer)
+        return r != 0
+      else
+        return r
+      end
     end
   end
-  class BotConfigIntegerValue < BotConfigValue
+
+  class IntegerValue < Value
     def parse(string)
+      return 1 if string == "true"
+      return 0 if string == "false"
       raise ArgumentError, "not an integer: #{string}" unless string =~ /^-?\d+$/
       string.to_i
     end
+    def get
+      r = super
+      if r.kind_of?(Integer)
+        return r
+      else
+        return r ? 1 : 0
+      end
+    end
   end
-  class BotConfigFloatValue < BotConfigValue
+
+  class FloatValue < Value
     def parse(string)
       raise ArgumentError, "not a float #{string}" unless string =~ /^-?[\d.]+$/
       string.to_f
     end
   end
-  class BotConfigArrayValue < BotConfigValue
+
+  class ArrayValue < Value
+    def initialize(key, params)
+      super
+      @validate_item = params[:validate_item]
+      @validate ||= Proc.new do |v|
+        !v.find { |i| !validate_item(i) }
+      end
+    end
+
+    def validate_item(item)
+      validate(item, @validate_item)
+    end
+
     def parse(string)
       string.split(/,\s+/)
     end
@@ -126,8 +182,13 @@ module Irc
       get.join(", ")
     end
     def add(val)
-      curval = self.get
-      set(curval + [val]) unless curval.include?(val)
+      newval = self.get.dup
+      unless newval.include? val
+        newval << val
+        validate_item(val) or raise ArgumentError, "invalid item: #{val}"
+        validate(newval) or raise ArgumentError, "invalid value: #{newval.to_s}"
+        set(newval)
+      end
     end
     def rm(val)
       curval = self.get
@@ -135,14 +196,15 @@ module Irc
       set(curval - [val])
     end
   end
-  class BotConfigEnumValue < BotConfigValue
+
+  class EnumValue < Value
     def initialize(key, params)
       super
       @values = params[:values]
     end
     def values
       if @values.instance_of?(Proc)
-        return @values.call(BotConfig.bot)
+        return @values.call(@manager.bot)
       else
         return @values
       end
@@ -154,240 +216,57 @@ module Irc
       string
     end
     def desc
-      "#{@desc} [valid values are: " + values.join(", ") + "]"
+      _("%{desc} [valid values are: %{values}]") % {:desc => @desc, :values => values.join(', ')}
     end
   end
 
   # container for bot configuration
-  class BotConfig
-    # Array of registered BotConfigValues for defaults, types and help
-    @@items = Hash.new
-    def BotConfig.items
-      @@items
-    end
-    # Hash containing key => value pairs for lookup and serialisation
-    @@config = Hash.new(false)
-    def BotConfig.config
-      @@config
-    end
-    def BotConfig.bot
-      @@bot
-    end
-    
-    def BotConfig.register(item)
-      unless item.kind_of?(BotConfigValue)
-        raise ArgumentError,"item must be a BotConfigValue"
-      end
-      @@items[item.key] = item
-    end
-
-    # currently we store values in a hash but this could be changed in the
-    # future. We use hash semantics, however.
-    # components that register their config keys and setup defaults are
-    # supported via []
-    def [](key)
-      return @@items[key].value if @@items.has_key?(key)
-      return @@items[key.intern].value if @@items.has_key?(key.intern)
-      # try to still support unregistered lookups
-      # but warn about them
-      if @@config.has_key?(key)
-        warning "Unregistered lookup #{key.inspect}"
-        return @@config[key]
-      end
-      if @@config.has_key?(key.intern)
-        warning "Unregistered lookup #{key.intern.inspect}"
-        return @@config[key.intern]
-      end
-      return false
-    end
+  class ManagerClass
 
-    # TODO should I implement this via BotConfigValue or leave it direct?
-    #    def []=(key, value)
-    #    end
-    
-    # pass everything else through to the hash
-    def method_missing(method, *args, &block)
-      return @@config.send(method, *args, &block)
-    end
+    include Singleton
 
-    def handle_list(m, params)
-      modules = []
-      if params[:module]
-        @@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 #{params[:module]}"
-        else
-          m.reply modules.join(", ")
-        end
-      else
-        @@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
+    attr_reader :bot
+    attr_reader :items
+    attr_reader :config
+    attr_reader :overrides
+    attr_accessor :changed
 
-    def handle_get(m, params)
-      key = params[:key].to_s.intern
-      unless @@items.has_key?(key)
-        m.reply "no such config key #{key}"
-        return
-      end
-      value = @@items[key].to_s
-      m.reply "#{key}: #{value}"
+    def initialize
+      bot_associate(nil,true)
     end
 
-    def handle_desc(m, params)
-      key = params[:key].to_s.intern
-      unless @@items.has_key?(key)
-        m.reply "no such config key #{key}"
-      end
-      puts @@items[key].inspect
-      m.reply "#{key}: #{@@items[key].desc}"
-    end
+    def reset_config
+      @items = Hash.new
+      @config = Hash.new(false)
 
-    def handle_unset(m, params)
-      key = params[:key].to_s.intern
-      unless @@items.has_key?(key)
-        m.reply "no such config key #{key}"
+      # We allow default values for config keys to be overridden by
+      # the config file /etc/rbot.conf
+      # The main purpose for this is to allow distro or system-wide
+      # settings such as external program paths (figlet, toilet, ispell)
+      # to be set once for all the bots.
+      @overrides = Hash.new
+      etcfile = "/etc/rbot.conf"
+      if File.exist?(etcfile)
+        log "Loading defaults from #{etcfile}"
+        etcconf = YAML::load_file(etcfile)
+        etcconf.each { |k, v|
+          @overrides[k.to_sym] = v
+        }
       end
-      @@items[key].unset
-      handle_get(m, params)
-      m.reply "this config change will take effect on the next restart" if @@items[key].requires_restart
     end
 
-    def handle_set(m, params)
-      key = params[:key].to_s.intern
-      value = params[:value].join(" ")
-      unless @@items.has_key?(key)
-        m.reply "no such config key #{key}"
-        return
-      end
-      begin
-        @@items[key].set_string(value)
-      rescue ArgumentError => e
-        m.reply "failed to set #{key}: #{e.message}"
-        return
-      end
-      if @@items[key].requires_restart
-        m.reply "this config change will take effect on the next restart"
-      else
-        m.okay
-      end
-    end
-
-    def handle_add(m, params)
-      key = params[:key].to_s.intern
-      value = params[:value]
-      unless @@items.has_key?(key)
-        m.reply "no such config key #{key}"
-        return
-      end
-      unless @@items[key].class <= BotConfigArrayValue
-        m.reply "config key #{key} is not an array"
-        return
-      end
-      begin
-        @@items[key].add(value)
-      rescue ArgumentError => e
-        m.reply "failed to add #{value} to #{key}: #{e.message}"
-        return
-      end
-      handle_get(m,{:key => key})
-      m.reply "this config change will take effect on the next restart" if @@items[key].requires_restart
-    end
-
-    def handle_rm(m, params)
-      key = params[:key].to_s.intern
-      value = params[:value]
-      unless @@items.has_key?(key)
-        m.reply "no such config key #{key}"
-        return
-      end
-      unless @@items[key].class <= BotConfigArrayValue
-        m.reply "config key #{key} is not an array"
-        return
-      end
-      begin
-        @@items[key].rm(value)
-      rescue ArgumentError => e
-        m.reply "failed to remove #{value} from #{key}: #{e.message}"
-        return
-      end
-      handle_get(m,{:key => key})
-      m.reply "this config change will take effect on the next restart" if @@items[key].requires_restart
-    end
-
-    def handle_help(m, params)
-      topic = params[:topic]
-      case topic
-      when false
-        m.reply "config module - bot configuration. usage: list, desc, get, set, unset, add, rm"
-      when "list"
-        m.reply "config list => list configuration modules, config list <module> => list configuration keys for module <module>"
-      when "get"
-        m.reply "config get <key> => get configuration value for key <key>"
-      when "unset"
-        m.reply "reset key <key> to the default"
-      when "set"
-        m.reply "config set <key> <value> => set configuration value for key <key> to <value>"
-      when "desc"
-        m.reply "config desc <key> => describe what key <key> configures"
-      when "add"
-        m.reply "config add <value> to <key> => add value <value> to key <key> if <key> is an array"
-      when "rm"
-        m.reply "config rm <value> from <key> => remove value <value> from key <key> if <key> is an array"
-      else
-        m.reply "no help for config #{topic}"
-      end
-    end
-    def usage(m,params)
-      m.reply "incorrect usage, try '#{@@bot.nick}: help config'"
-    end
+    # Associate with bot _bot_
+    def bot_associate(bot, reset=false)
+      reset_config if reset
+      @bot = bot
+      return unless @bot
 
-    # bot:: parent bot class
-    # create a new config hash from #{botclass}/conf.rbot
-    def initialize(bot)
-      @@bot = bot
-
-      # respond to config messages, to provide runtime configuration
-      # management
-      # messages will be:
-      #  get
-      #  set
-      #  unset
-      #  desc
-      #  and for arrays:
-      #    add TODO
-      #    remove TODO
-      @handler = MessageMapper.new(self)
-      @handler.map 'config list :module', :action => 'handle_list',
-                   :defaults => {:module => false}
-      @handler.map 'config get :key', :action => 'handle_get'
-      @handler.map 'config desc :key', :action => 'handle_desc'
-      @handler.map 'config describe :key', :action => 'handle_desc'
-      @handler.map 'config set :key *value', :action => 'handle_set'
-      @handler.map 'config add :value to :key', :action => 'handle_add'
-      @handler.map 'config rm :value from :key', :action => 'handle_rm'
-      @handler.map 'config del :value from :key', :action => 'handle_rm'
-      @handler.map 'config delete :value from :key', :action => 'handle_rm'
-      @handler.map 'config unset :key', :action => 'handle_unset'
-      @handler.map 'config reset :key', :action => 'handle_unset'
-      @handler.map 'config help :topic', :action => 'handle_help',
-                   :defaults => {:topic => false}
-      @handler.map 'help config :topic', :action => 'handle_help',
-                   :defaults => {:topic => false}
-      
-      if(File.exist?("#{@@bot.botclass}/conf.yaml"))
+      @changed = false
+      if(File.exist?("#{@bot.botclass}/conf.yaml"))
         begin
-          newconfig = YAML::load_file("#{@@bot.botclass}/conf.yaml")
+          newconfig = YAML::load_file("#{@bot.botclass}/conf.yaml")
           newconfig.each { |key, val|
-            @@config[key.intern] = val
+            @config[key.to_sym] = val
           }
           return
         rescue
@@ -395,56 +274,109 @@ module Irc
         end
       end
       # if we got here, we need to run the first-run wizard
-      BotConfigWizard.new(@@bot).run
+      Wizard.new(@bot).run
       # save newly created config
+      @changed = true
       save
     end
 
+    def register(item)
+      unless item.kind_of?(Value)
+        raise ArgumentError,"item must be an Irc::Bot::Config::Value"
+      end
+      @items[item.key] = item
+    end
+
+    # currently we store values in a hash but this could be changed in the
+    # future. We use hash semantics, however.
+    # components that register their config keys and setup defaults are
+    # supported via []
+    def [](key)
+      # return @items[key].value if @items.has_key?(key)
+      return @items[key.to_sym].value if @items.has_key?(key.to_sym)
+      # try to still support unregistered lookups
+      # but warn about them
+      #      if @config.has_key?(key)
+      #        warning "Unregistered lookup #{key.inspect}"
+      #        return @config[key]
+      #      end
+      if @config.has_key?(key.to_sym)
+        warning _("Unregistered lookup #{key.to_sym.inspect}")
+        return @config[key.to_sym]
+      end
+      return false
+    end
+
+    def []=(key, value)
+      return @items[key.to_sym].set(value) if @items.has_key?(key.to_sym)
+      if @config.has_key?(key.to_sym)
+        warning _("Unregistered lookup #{key.to_sym.inspect}")
+        return @config[key.to_sym] = value
+      end
+    end
+
+    # pass everything else through to the hash
+    def method_missing(method, *args, &block)
+      return @config.send(method, *args, &block)
+    end
+
     # write current configuration to #{botclass}/conf.yaml
     def save
+      if not @changed
+        debug "Not writing conf.yaml (unchanged)"
+        return
+      end
       begin
         debug "Writing new conf.yaml ..."
-        File.open("#{@@bot.botclass}/conf.yaml.new", "w") do |file|
+        File.open("#{@bot.botclass}/conf.yaml.new", "w") do |file|
           savehash = {}
-          @@config.each { |key, val|
+          @config.each { |key, val|
             savehash[key.to_s] = val
           }
           file.puts savehash.to_yaml
         end
         debug "Officializing conf.yaml ..."
-        File.rename("#{@@bot.botclass}/conf.yaml.new",
-                    "#{@@bot.botclass}/conf.yaml")
+        File.rename("#{@bot.botclass}/conf.yaml.new",
+                    "#{@bot.botclass}/conf.yaml")
+        @changed = false
       rescue => e
         error "failed to write configuration file conf.yaml! #{$!}"
         error "#{e.class}: #{e}"
         error e.backtrace.join("\n")
       end
     end
+  end
 
-    def privmsg(m)
-      @handler.handle(m)
-    end
+  # Returns the only Irc::Bot::Config::ManagerClass
+  #
+  def Config.manager
+    return ManagerClass.instance
+  end
+
+  # Register a config value
+  def Config.register(item)
+    Config.manager.register(item)
   end
 
-  class BotConfigWizard
+  class Wizard
     def initialize(bot)
       @bot = bot
-      @questions = BotConfig.items.values.find_all {|i| i.wizard }
+      @manager = Config.manager
+      @questions = @manager.items.values.find_all {|i| i.wizard }
     end
-    
+
     def run()
-      puts "First time rbot configuration wizard"
+      $stdout.sync = true
+      puts _("First time rbot configuration wizard")
       puts "===================================="
-      puts "This is the first time you have run rbot with a config directory of:"
-      puts @bot.botclass
-      puts "This wizard will ask you a few questions to get you started."
-      puts "The rest of rbot's configuration can be manipulated via IRC once"
-      puts "rbot is connected and you are auth'd."
+      puts _("This is the first time you have run rbot with a config directory of: #{@bot.botclass}")
+      puts _("This wizard will ask you a few questions to get you started.")
+      puts _("The rest of rbot's configuration can be manipulated via IRC once rbot is connected and you are auth'd.")
       puts "-----------------------------------"
 
       return unless @questions
       @questions.sort{|a,b| a.order <=> b.order }.each do |q|
-        puts q.desc
+        puts _(q.desc)
         begin
           print q.key.to_s + " [#{q.to_s}]: "
           response = STDIN.gets
@@ -452,13 +384,16 @@ module Irc
           unless response.empty?
             q.set_string response, false
           end
-          puts "configured #{q.key} => #{q.to_s}"
+          puts _("configured #{q.key} => #{q.to_s}")
           puts "-----------------------------------"
         rescue ArgumentError => e
-          puts "failed to set #{q.key}: #{e.message}"
+          puts _("failed to set #{q.key}: #{e.message}")
           retry
         end
       end
     end
   end
+
+end
+end
 end