224 lines
7.5 KiB
Python
224 lines
7.5 KiB
Python
# Copyright 2010-2011 Florent Le Coz <louiz@louiz.org>
|
||
#
|
||
# This file is part of Poezio.
|
||
#
|
||
# Poezio is free software: you can redistribute it and/or modify
|
||
# it under the terms of the zlib license. See the COPYING file.
|
||
|
||
"""
|
||
Defines the global config instance, used to get or set (and save) values
|
||
from/to the config file
|
||
"""
|
||
|
||
DEFSECTION = "Poezio"
|
||
|
||
from configparser import RawConfigParser, NoOptionError, NoSectionError
|
||
from os import environ, makedirs, path
|
||
from shutil import copy2
|
||
from args import parse_args
|
||
from common import safeJID
|
||
|
||
|
||
class Config(RawConfigParser):
|
||
"""
|
||
load/save the config to a file
|
||
"""
|
||
def __init__(self, file_name):
|
||
self.file_name = file_name
|
||
RawConfigParser.__init__(self, None)
|
||
# make the options case sensitive
|
||
self.optionxform = str
|
||
try:
|
||
RawConfigParser.read(self, file_name, encoding='utf-8')
|
||
except TypeError: # python < 3.2 sucks
|
||
RawConfigParser.read(self, file_name)
|
||
# Check config integrity and fix it if it’s wrong
|
||
for section in ('bindings', 'var'):
|
||
if not self.has_section(section):
|
||
self.add_section(section)
|
||
|
||
def get(self, option, default, section=DEFSECTION):
|
||
"""
|
||
get a value from the config but return
|
||
a default value if it is not found
|
||
The type of default defines the type
|
||
returned
|
||
"""
|
||
try:
|
||
if type(default) == int:
|
||
res = self.getint(option, section)
|
||
elif type(default) == float:
|
||
res = self.getfloat(option, section)
|
||
elif type(default) == bool:
|
||
res = self.getboolean(option, section)
|
||
else:
|
||
res = self.getstr(option, section)
|
||
except (NoOptionError, NoSectionError):
|
||
return default
|
||
return res
|
||
|
||
def getl(self, option, default, section=DEFSECTION):
|
||
"""
|
||
get a value and return it lowercase
|
||
"""
|
||
return self.get(option, default, section).lower()
|
||
|
||
def get_by_tabname(self, option, default, tabname, fallback=True, fallback_server=True):
|
||
"""
|
||
Try to get the value for the option. First we look in
|
||
a section named `tabname`, if the option is not present
|
||
in the section, we search for the global option if fallback is
|
||
True. And we return `default` as a fallback as a last resort.
|
||
"""
|
||
if tabname in self.sections():
|
||
if option in self.options(tabname):
|
||
# We go the tab-specific option
|
||
return self.get(option, default, tabname)
|
||
if fallback_server:
|
||
return self.get_by_servname(tabname, option, default, fallback)
|
||
if fallback:
|
||
# We fallback to the global option
|
||
return self.get(option, default)
|
||
return default
|
||
|
||
def get_by_servname(self, jid, option, default, fallback=True):
|
||
"""
|
||
Try to get the value of an option for a server
|
||
"""
|
||
server = safeJID(jid).server
|
||
if server:
|
||
server = '@' + server
|
||
if server in self.sections() and option in self.options(server):
|
||
return self.get(option, default, server)
|
||
if fallback:
|
||
return self.get(option, default)
|
||
return default
|
||
|
||
|
||
def __get(self, option, section=DEFSECTION):
|
||
"""
|
||
facility for RawConfigParser.get
|
||
"""
|
||
return RawConfigParser.get(self, section, option)
|
||
|
||
def getstr(self, option, section=DEFSECTION):
|
||
"""
|
||
get a value and returns it as a string
|
||
"""
|
||
return self.__get(option, section)
|
||
|
||
def getint(self, option, section=DEFSECTION):
|
||
"""
|
||
get a value and returns it as an int
|
||
"""
|
||
try:
|
||
return int(self.__get(option, section))
|
||
except ValueError:
|
||
return -1
|
||
|
||
def getfloat(self, option, section=DEFSECTION):
|
||
"""
|
||
get a value and returns it as a float
|
||
"""
|
||
return float(self.__get(option, section))
|
||
|
||
def getboolean(self, option, section=DEFSECTION):
|
||
"""
|
||
get a value and returns it as a boolean
|
||
"""
|
||
return RawConfigParser.getboolean(self, section, option)
|
||
|
||
def write_in_file(self, section, option, value):
|
||
"""
|
||
Our own way to save write the value in the file
|
||
Just find the right section, and then find the
|
||
right option, and edit it.
|
||
|
||
TODO: make it write also new values in the file, not just what did already
|
||
exist
|
||
"""
|
||
if path.exists(self.file_name):
|
||
df = open(self.file_name, 'r', encoding='utf-8')
|
||
lines_before = (line.strip() for line in df.readlines())
|
||
df.close()
|
||
else:
|
||
lines_before = []
|
||
result_lines = []
|
||
we_are_in_the_right_section = False
|
||
written = False
|
||
section_found = False
|
||
for line in lines_before:
|
||
if line.startswith('['): # check the section
|
||
if we_are_in_the_right_section and not written:
|
||
result_lines.append('%s = %s' % (option, value))
|
||
written = True
|
||
if line == '[%s]' % section:
|
||
we_are_in_the_right_section = True
|
||
section_found = True
|
||
else:
|
||
we_are_in_the_right_section = False
|
||
if (line.startswith('%s ' % (option,)) or
|
||
line.startswith('%s=' % (option,)) or
|
||
line.startswith('%s = ' % (option,))) and we_are_in_the_right_section:
|
||
line = '%s = %s' % (option, value)
|
||
written = True
|
||
result_lines.append(line)
|
||
|
||
if not section_found:
|
||
result_lines.append('[%s]' % section)
|
||
result_lines.append('%s = %s' % (option, value))
|
||
elif not written:
|
||
result_lines.append('%s = %s' % (option, value))
|
||
|
||
|
||
df = open(self.file_name, 'w', encoding='utf-8')
|
||
for line in result_lines:
|
||
df.write('%s\n' % line)
|
||
df.close()
|
||
|
||
def set_and_save(self, option, value, section=DEFSECTION):
|
||
"""
|
||
set the value in the configuration then save it
|
||
to the file
|
||
"""
|
||
# Special case for a 'toggle' value. We take the current value
|
||
# and set the opposite. Warning if the no current value exists
|
||
# or it is not a bool.
|
||
if value == "toggle":
|
||
current = self.get(option, "", section)
|
||
if current.lower() == "false":
|
||
value = "true"
|
||
elif current.lower() == "true":
|
||
value = "false"
|
||
else:
|
||
return "Could not toggle option: %s. Current value is %s." % (option, current or "empty")
|
||
if self.has_section(section):
|
||
RawConfigParser.set(self, section, option, value)
|
||
else:
|
||
self.add_section(section)
|
||
RawConfigParser.set(self, section, option, value)
|
||
self.write_in_file(section, option, value)
|
||
return "%s=%s" % (option, value)
|
||
|
||
|
||
def set(self, option, value, section=DEFSECTION):
|
||
"""
|
||
Set the value of an option temporarily
|
||
"""
|
||
try:
|
||
RawConfigParser.set(self, section, option, value)
|
||
except NoSectionError:
|
||
pass
|
||
|
||
|
||
# creates the configuration directory if it doesn't exist
|
||
# and copy the default config in it
|
||
|
||
#options = parse_args(CONFIG_PATH)
|
||
class Stub(object):
|
||
def __getattribute__(self, v):
|
||
def stub_func(self, *args, **kwargs): return ''
|
||
return stub_func
|
||
|
||
options = Stub()
|
||
config = Stub()
|