-module Irc
+require 'singleton'
+
+require 'yaml'
+
+unless YAML.respond_to?(:load_file)
+ def YAML.load_file( filepath )
+ File.open( filepath ) do |f|
+ YAML::load( f )
+ end
+ end
+end
- require 'yaml'
- require 'rbot/messagemapper'
- class BotConfigValue
+module Irc
+
+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
attr_reader :desc
attr_reader :key
attr_reader :wizard
+ attr_reader :store_default
attr_reader :requires_restart
+ attr_reader :requires_rescan
attr_reader :order
+ attr_reader :manager
+ attr_reader :auth_path
def initialize(key, params)
- unless key =~ /^.+\..+$/
+ @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.
+ unless key.to_s =~ /^.+\..+$/
raise ArgumentError,"key must be of the form 'module.name'"
end
@order = @@order
@@order += 1
- @key = key
- 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
@on_change = params[:on_change]
@validate = params[:validate]
@wizard = params[:wizard]
+ @store_default = params[:store_default]
@requires_restart = params[:requires_restart]
+ @requires_rescan = params[:requires_rescan]
+ @auth_path = "config::key::#{key.sub('.','::')}"
end
def default
if @default.instance_of?(Proc)
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
raise ArgumentError, "invalid value: #{string}"
end
end
-
+
# override this. the default will work for strings only
def parse(string)
string
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
def to_s
get.join(", ")
end
+ def add(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.inspect}"
+ set(newval)
+ end
+ end
+ def rm(val)
+ curval = self.get
+ raise ArgumentError, "value #{val} not present" unless curval.include?(val)
+ 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
end
def parse(string)
- unless @values.include?(string)
- raise ArgumentError, "invalid value #{string}, allowed values are: " + @values.join(", ")
+ unless values.include?(string)
+ raise ArgumentError, "invalid value #{string}, allowed values are: " + values.join(", ")
end
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
+ class ManagerClass
- # 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)
- # try to still support unregistered lookups
- return @@config[key] if @@config.has_key?(key)
- return false
- end
+ include Singleton
- # 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
+ attr_reader :bot
+ attr_reader :items
+ attr_reader :config
+ attr_reader :overrides
+ attr_accessor :changed
- def handle_list(m, params)
- modules = []
- if params[:module]
- @@items.each_key do |key|
- mod, name = key.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.split('.').first
- modules.push name unless modules.include?(name)
- end
- m.reply "modules: " + modules.join(", ")
- end
+ def initialize
+ bot_associate(nil,true)
end
- def handle_get(m, params)
- key = params[:key]
- unless @@items.has_key?(key)
- m.reply "no such config key #{key}"
- return
+ def reset_config
+ @items = Hash.new
+ @config = Hash.new(false)
+
+ # 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
- value = @@items[key].to_s
- m.reply "#{key}: #{value}"
end
- def handle_desc(m, params)
- key = params[:key]
- unless @@items.has_key?(key)
- m.reply "no such config key #{key}"
+ # Associate with bot _bot_
+ def bot_associate(bot, reset=false)
+ reset_config if reset
+ @bot = bot
+ return unless @bot
+
+ @changed = false
+ conf = @bot.path 'conf.yaml'
+ if File.exist? conf
+ begin
+ newconfig = YAML::load_file conf
+ newconfig.each { |key, val|
+ @config[key.to_sym] = val
+ }
+ return
+ rescue
+ error "failed to read conf.yaml: #{$!}"
+ end
+ end
+ # config options with :store_default to true should store
+ # their default value at first run.
+ # Some defaults might change anytime the bot starts
+ # for instance core.db or authpw
+ @items.values.find_all {|i| i.store_default }.each do |value|
+ @config[value.key] = value.default
end
- puts @@items[key].inspect
- m.reply "#{key}: #{@@items[key].desc}"
+
+ # if we got here, we need to run the first-run wizard
+ Wizard.new(@bot).run
+ # save newly created config
+ @changed = true
+ save
end
- def handle_unset(m, params)
- key = params[:key]
- unless @@items.has_key?(key)
- m.reply "no such config key #{key}"
+ def register(item)
+ unless item.kind_of?(Value)
+ raise ArgumentError,"item must be an Irc::Bot::Config::Value"
end
- @@items[key].unset
- handle_get(m, params)
+ @items[item.key] = item
end
- def handle_set(m, params)
- key = params[:key]
- value = params[:value].to_s
- 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
+ # 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 handle_help(m, params)
- topic = params[:topic]
- case topic
- when false
- m.reply "config module - bot configuration. usage: list, desc, get, set, unset"
- 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"
- else
- m.reply "no help for config #{topic}"
+ 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
- def usage(m,params)
- m.reply "incorrect usage, try '#{@@bot.nick}: help config'"
- end
- # 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 unset :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"))
- newconfig = YAML::load_file("#{@@bot.botclass}/conf.yaml")
- @@config.update newconfig
- else
- # first-run wizard!
- BotConfigWizard.new(@@bot).run
- # save newly created config
- save
- 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.rbot
+ # write current configuration to #{botclass}/conf.yaml
def save
- File.open("#{@@bot.botclass}/conf.yaml", "w") do |file|
- file.puts @@config.to_yaml
+ if not @changed
+ debug "Not writing conf.yaml (unchanged)"
+ return
+ end
+ begin
+ conf = @bot.path 'conf.yaml'
+ fnew = conf + '.new'
+ debug "Writing new conf.yaml ..."
+ File.open(fnew, "w") do |file|
+ savehash = {}
+ @config.each { |key, val|
+ savehash[key.to_s] = val
+ }
+ file.puts savehash.to_yaml
+ end
+ debug "Officializing conf.yaml ..."
+ File.rename(fnew, conf)
+ @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
- class BotConfigWizard
+ # Register a config value
+ def Config.register(item)
+ Config.manager.register(item)
+ end
+
+ 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 + " [#{q.to_s}]: "
+ print q.key.to_s + " [#{q.to_s}]: "
response = STDIN.gets
response.chop!
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
projects / user / henk / code / ruby / rbot.git / blobdiff