fcbd69e209
We already attempted this in c5a2039da4, but
having the directories as module attributes means they'll be created on start
(rather than when they're actually used), and it'd also be impossible to change
them after init for some reason in the future.
To still have a nice short API, we simply change the attributes to functions.
725 lines
27 KiB
Python
725 lines
27 KiB
Python
# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
|
|
|
|
# Copyright 2014-2015 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
|
|
#
|
|
# This file is part of qutebrowser.
|
|
#
|
|
# qutebrowser is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# qutebrowser is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with qutebrowser. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
"""Configuration storage and config-related utilities.
|
|
|
|
This borrows a lot of ideas from configparser, but also has some things that
|
|
are fundamentally different. This is why nothing inherts from configparser, but
|
|
we borrow some methods and classes from there where it makes sense.
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import os.path
|
|
import functools
|
|
import configparser
|
|
import collections
|
|
import collections.abc
|
|
|
|
from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QUrl, QSettings
|
|
from PyQt5.QtWidgets import QMessageBox
|
|
|
|
from qutebrowser.config import configdata, configexc, textwrapper
|
|
from qutebrowser.config.parsers import ini, keyconf
|
|
from qutebrowser.commands import cmdexc, cmdutils
|
|
from qutebrowser.utils import message, objreg, utils, standarddir, log, qtutils
|
|
from qutebrowser.utils.usertypes import Completion
|
|
|
|
|
|
class change_filter: # pylint: disable=invalid-name
|
|
|
|
"""Decorator to register a new command handler.
|
|
|
|
This could also be a function, but as a class (with a "wrong" name) it's
|
|
much cleaner to implement.
|
|
|
|
Attributes:
|
|
_sectname: The section to be filtered.
|
|
_optname: The option to be filtered.
|
|
"""
|
|
|
|
def __init__(self, sectname, optname=None):
|
|
"""Save decorator arguments.
|
|
|
|
Gets called on parse-time with the decorator arguments.
|
|
|
|
Args:
|
|
See class attributes.
|
|
"""
|
|
if sectname not in configdata.DATA:
|
|
raise configexc.NoSectionError(sectname)
|
|
if optname is not None and optname not in configdata.DATA[sectname]:
|
|
raise configexc.NoOptionError(optname, sectname)
|
|
self._sectname = sectname
|
|
self._optname = optname
|
|
|
|
def __call__(self, func):
|
|
"""Register the command before running the function.
|
|
|
|
Gets called when a function should be decorated.
|
|
|
|
Adds a filter which returns if we're not interested in the change-event
|
|
and calls the wrapped function if we are.
|
|
|
|
We assume the function passed doesn't take any parameters.
|
|
|
|
Args:
|
|
func: The function to be decorated.
|
|
|
|
Return:
|
|
The decorated function.
|
|
"""
|
|
|
|
@pyqtSlot(str, str)
|
|
@functools.wraps(func)
|
|
def wrapper(wrapper_self, sectname=None, optname=None):
|
|
# pylint: disable=missing-docstring
|
|
if sectname is None and optname is None:
|
|
# Called directly, not from a config change event.
|
|
return func(wrapper_self)
|
|
elif sectname != self._sectname:
|
|
return
|
|
elif self._optname is not None and optname != self._optname:
|
|
return
|
|
else:
|
|
return func(wrapper_self)
|
|
|
|
return wrapper
|
|
|
|
|
|
def get(*args, **kwargs):
|
|
"""Convenience method to call get(...) of the config instance."""
|
|
return objreg.get('config').get(*args, **kwargs)
|
|
|
|
|
|
def section(sect):
|
|
"""Get a config section from the global config."""
|
|
return objreg.get('config')[sect]
|
|
|
|
|
|
def _init_main_config():
|
|
"""Initialize the main config."""
|
|
try:
|
|
app = objreg.get('app')
|
|
config_obj = ConfigManager(standarddir.config(), 'qutebrowser.conf',
|
|
app)
|
|
except (configexc.Error, configparser.Error, UnicodeDecodeError) as e:
|
|
log.init.exception(e)
|
|
errstr = "Error while reading config:"
|
|
try:
|
|
errstr += "\n\n{} -> {}:".format(
|
|
e.section, e.option) # pylint: disable=no-member
|
|
except AttributeError:
|
|
pass
|
|
errstr += "\n{}".format(e)
|
|
msgbox = QMessageBox(QMessageBox.Critical,
|
|
"Error while reading config!", errstr)
|
|
msgbox.exec_()
|
|
# We didn't really initialize much so far, so we just quit hard.
|
|
sys.exit(1)
|
|
else:
|
|
objreg.register('config', config_obj)
|
|
if standarddir.config() is not None:
|
|
filename = os.path.join(standarddir.config(), 'qutebrowser.conf')
|
|
save_manager = objreg.get('save-manager')
|
|
save_manager.add_saveable(
|
|
'config', config_obj.save, config_obj.changed,
|
|
config_opt=('general', 'auto-save-config'), filename=filename)
|
|
for sect in config_obj.sections.values():
|
|
for opt in sect.values.values():
|
|
if opt.values['conf'] is None:
|
|
# Option added to builtin defaults but not in user's
|
|
# config yet
|
|
save_manager.save('config', explicit=True, force=True)
|
|
return
|
|
|
|
|
|
def _init_key_config():
|
|
"""Initialize the key config."""
|
|
try:
|
|
key_config = keyconf.KeyConfigParser(standarddir.config(), 'keys.conf')
|
|
except (keyconf.KeyConfigError, UnicodeDecodeError) as e:
|
|
log.init.exception(e)
|
|
errstr = "Error while reading key config:\n"
|
|
if e.lineno is not None:
|
|
errstr += "In line {}: ".format(e.lineno)
|
|
errstr += str(e)
|
|
msgbox = QMessageBox(QMessageBox.Critical,
|
|
"Error while reading key config!", errstr)
|
|
msgbox.exec_()
|
|
# We didn't really initialize much so far, so we just quit hard.
|
|
sys.exit(1)
|
|
else:
|
|
objreg.register('key-config', key_config)
|
|
if standarddir.config() is not None:
|
|
save_manager = objreg.get('save-manager')
|
|
filename = os.path.join(standarddir.config(), 'keys.conf')
|
|
save_manager.add_saveable(
|
|
'key-config', key_config.save, key_config.changed,
|
|
config_opt=('general', 'auto-save-config'), filename=filename)
|
|
|
|
|
|
def _init_misc():
|
|
"""Initialize misc. config-related files."""
|
|
save_manager = objreg.get('save-manager')
|
|
state_config = ini.ReadWriteConfigParser(standarddir.data(), 'state')
|
|
objreg.register('state-config', state_config)
|
|
save_manager.add_saveable('state-config', state_config.save)
|
|
|
|
# We need to import this here because lineparser needs config.
|
|
from qutebrowser.config.parsers import line
|
|
command_history = line.LineConfigParser(standarddir.data(), 'cmd-history',
|
|
('completion', 'history-length'),
|
|
parent=objreg.get('config'))
|
|
objreg.register('command-history', command_history)
|
|
save_manager.add_saveable('command-history', command_history.save,
|
|
command_history.changed)
|
|
|
|
# Set the QSettings path to something like
|
|
# ~/.config/qutebrowser/qsettings/qutebrowser/qutebrowser.conf so it
|
|
# doesn't overwrite our config.
|
|
#
|
|
# This fixes one of the corruption issues here:
|
|
# https://github.com/The-Compiler/qutebrowser/issues/515
|
|
|
|
if standarddir.config() is None:
|
|
path = os.devnull
|
|
else:
|
|
path = os.path.join(standarddir.config(), 'qsettings')
|
|
for fmt in (QSettings.NativeFormat, QSettings.IniFormat):
|
|
QSettings.setPath(fmt, QSettings.UserScope, path)
|
|
|
|
|
|
def init():
|
|
"""Initialize the config."""
|
|
_init_main_config()
|
|
_init_key_config()
|
|
_init_misc()
|
|
|
|
|
|
class ConfigManager(QObject):
|
|
|
|
"""Configuration manager for qutebrowser.
|
|
|
|
Class attributes:
|
|
KEY_ESCAPE: Chars which need escaping when they occur as first char
|
|
in a line.
|
|
ESCAPE_CHAR: The char to be used for escaping
|
|
RENAMED_SECTIONS: A mapping of renamed sections, {'oldname': 'newname'}
|
|
RENAMED_OPTIONS: A mapping of renamed options,
|
|
{('section', 'oldname'): 'newname'}
|
|
DELETED_OPTIONS: A (section, option) list of deleted options.
|
|
|
|
Attributes:
|
|
sections: The configuration data as an OrderedDict.
|
|
_fname: The filename to be opened.
|
|
_configdir: The dictionary to read the config from and save it in.
|
|
_interpolation: An configparser.Interpolation object
|
|
_proxies: configparser.SectionProxy objects for sections.
|
|
_initialized: Whether the ConfigManager is fully initialized yet.
|
|
|
|
Signals:
|
|
changed: Emitted when a config option changed.
|
|
style_changed: When style caches need to be invalidated.
|
|
Args: the changed section and option.
|
|
"""
|
|
|
|
KEY_ESCAPE = r'\#['
|
|
ESCAPE_CHAR = '\\'
|
|
RENAMED_SECTIONS = {
|
|
'permissions': 'content'
|
|
}
|
|
RENAMED_OPTIONS = {
|
|
('colors', 'tab.fg.odd'): 'tabs.fg.odd',
|
|
('colors', 'tab.fg.even'): 'tabs.fg.even',
|
|
('colors', 'tab.fg.selected'): 'tabs.fg.selected',
|
|
('colors', 'tab.bg.odd'): 'tabs.bg.odd',
|
|
('colors', 'tab.bg.even'): 'tabs.bg.even',
|
|
('colors', 'tab.bg.selected'): 'tabs.bg.selected',
|
|
('colors', 'tab.bg.bar'): 'tabs.bg.bar',
|
|
('colors', 'tab.indicator.start'): 'tabs.indicator.start',
|
|
('colors', 'tab.indicator.stop'): 'tabs.indicator.stop',
|
|
('colors', 'tab.indicator.error'): 'tabs.indicator.error',
|
|
('colors', 'tab.indicator.system'): 'tabs.indicator.system',
|
|
('tabs', 'auto-hide'): 'hide-auto',
|
|
}
|
|
DELETED_OPTIONS = [
|
|
('colors', 'tab.seperator'),
|
|
('colors', 'tabs.seperator'),
|
|
]
|
|
|
|
changed = pyqtSignal(str, str)
|
|
style_changed = pyqtSignal(str, str)
|
|
|
|
def __init__(self, configdir, fname, parent=None):
|
|
super().__init__(parent)
|
|
self._initialized = False
|
|
self.sections = configdata.DATA
|
|
self._interpolation = configparser.ExtendedInterpolation()
|
|
self._proxies = {}
|
|
for sectname in self.sections.keys():
|
|
self._proxies[sectname] = SectionProxy(self, sectname)
|
|
self._fname = fname
|
|
if configdir is None:
|
|
self._configdir = None
|
|
self._initialized = True
|
|
else:
|
|
self._configdir = configdir
|
|
parser = ini.ReadConfigParser(configdir, fname)
|
|
self._from_cp(parser)
|
|
self._initialized = True
|
|
self._validate_all()
|
|
|
|
def __getitem__(self, key):
|
|
"""Get a section from the config."""
|
|
return self._proxies[key]
|
|
|
|
def __repr__(self):
|
|
return utils.get_repr(self, fname=self._fname)
|
|
|
|
def __str__(self):
|
|
"""Get the whole config as a string."""
|
|
lines = configdata.FIRST_COMMENT.strip('\n').splitlines()
|
|
for sectname, sect in self.sections.items():
|
|
lines.append('\n[{}]'.format(sectname))
|
|
lines += self._str_section_desc(sectname)
|
|
lines += self._str_option_desc(sectname, sect)
|
|
lines += self._str_items(sect)
|
|
return '\n'.join(lines) + '\n'
|
|
|
|
def _str_section_desc(self, sectname):
|
|
"""Get the section description string for sectname."""
|
|
wrapper = textwrapper.TextWrapper()
|
|
lines = []
|
|
seclines = configdata.SECTION_DESC[sectname].splitlines()
|
|
for secline in seclines:
|
|
if 'http://' in secline or 'https://' in secline:
|
|
lines.append('# ' + secline)
|
|
else:
|
|
lines += wrapper.wrap(secline)
|
|
return lines
|
|
|
|
def _str_option_desc(self, sectname, sect):
|
|
"""Get the option description strings for sect/sectname."""
|
|
wrapper = textwrapper.TextWrapper(initial_indent='#' + ' ' * 5,
|
|
subsequent_indent='#' + ' ' * 5)
|
|
lines = []
|
|
if not getattr(sect, 'descriptions', None):
|
|
return lines
|
|
for optname, option in sect.items():
|
|
lines.append('#')
|
|
if option.typ.typestr is None:
|
|
typestr = ''
|
|
else:
|
|
typestr = ' ({})'.format(option.typ.typestr)
|
|
lines.append("# {}{}:".format(optname, typestr))
|
|
try:
|
|
desc = self.sections[sectname].descriptions[optname]
|
|
except KeyError:
|
|
log.misc.exception("No description for {}.{}!".format(
|
|
sectname, optname))
|
|
continue
|
|
for descline in desc.splitlines():
|
|
lines += wrapper.wrap(descline)
|
|
valid_values = option.typ.valid_values
|
|
if valid_values is not None:
|
|
if valid_values.descriptions:
|
|
for val in valid_values:
|
|
desc = valid_values.descriptions[val]
|
|
lines += wrapper.wrap(" {}: {}".format(val, desc))
|
|
else:
|
|
lines += wrapper.wrap("Valid values: {}".format(', '.join(
|
|
valid_values)))
|
|
lines += wrapper.wrap("Default: {}".format(
|
|
option.values['default']))
|
|
return lines
|
|
|
|
def _str_items(self, sect):
|
|
"""Get the option items as string for sect."""
|
|
lines = []
|
|
for optname, option in sect.items():
|
|
value = option.value(startlayer='conf')
|
|
for c in self.KEY_ESCAPE:
|
|
if optname.startswith(c):
|
|
optname = optname.replace(c, self.ESCAPE_CHAR + c, 1)
|
|
# configparser can't handle = in keys :(
|
|
optname = optname.replace('=', '<eq>')
|
|
keyval = '{} = {}'.format(optname, value)
|
|
lines.append(keyval)
|
|
return lines
|
|
|
|
def _get_real_sectname(self, cp, sectname):
|
|
"""Get an old or new section name based on a configparser.
|
|
|
|
This checks if sectname is in cp, and if not, migrates it if needed and
|
|
tries again.
|
|
|
|
Args:
|
|
cp: The configparser to check.
|
|
sectname: The new section name.
|
|
|
|
Returns:
|
|
The section name in the configparser as a string, or None if the
|
|
configparser doesn't contain the section.
|
|
"""
|
|
reverse_renamed_sections = {v: k for k, v in
|
|
self.RENAMED_SECTIONS.items()}
|
|
if sectname in reverse_renamed_sections:
|
|
old_sectname = reverse_renamed_sections[sectname]
|
|
else:
|
|
old_sectname = sectname
|
|
if old_sectname in cp:
|
|
return old_sectname
|
|
elif sectname in cp:
|
|
return sectname
|
|
else:
|
|
return None
|
|
|
|
def _from_cp(self, cp):
|
|
"""Read the config from a configparser instance.
|
|
|
|
Args:
|
|
cp: The configparser instance to read the values from.
|
|
"""
|
|
for sectname in cp:
|
|
if sectname in self.RENAMED_SECTIONS:
|
|
sectname = self.RENAMED_SECTIONS[sectname]
|
|
if sectname is not 'DEFAULT' and sectname not in self.sections:
|
|
raise configexc.NoSectionError(sectname)
|
|
for sectname in self.sections:
|
|
real_sectname = self._get_real_sectname(cp, sectname)
|
|
if real_sectname is None:
|
|
continue
|
|
for k, v in cp[real_sectname].items():
|
|
if k.startswith(self.ESCAPE_CHAR):
|
|
k = k[1:]
|
|
if (sectname, k) in self.DELETED_OPTIONS:
|
|
continue
|
|
elif (sectname, k) in self.RENAMED_OPTIONS:
|
|
k = self.RENAMED_OPTIONS[sectname, k]
|
|
self.set('conf', sectname, k, v, validate=False)
|
|
|
|
def _validate_all(self):
|
|
"""Validate all values set in self._from_cp."""
|
|
for sectname, sect in self.sections.items():
|
|
mapping = {key: val.value() for key, val in sect.values.items()}
|
|
for optname, opt in sect.items():
|
|
interpolated = self._interpolation.before_get(
|
|
self, sectname, optname, opt.value(), mapping)
|
|
try:
|
|
opt.typ.validate(interpolated)
|
|
except configexc.ValidationError as e:
|
|
e.section = sectname
|
|
e.option = optname
|
|
raise
|
|
|
|
def _changed(self, sectname, optname):
|
|
"""Notify other objects the config has changed."""
|
|
log.misc.debug("Config option changed: {} -> {}".format(
|
|
sectname, optname))
|
|
if sectname in ('colors', 'fonts'):
|
|
self.style_changed.emit(sectname, optname)
|
|
self.changed.emit(sectname, optname)
|
|
|
|
def _after_set(self, changed_sect, changed_opt):
|
|
"""Clean up caches and emit signals after an option has been set."""
|
|
self.get.cache_clear()
|
|
self._changed(changed_sect, changed_opt)
|
|
# Options in the same section and ${optname} interpolation.
|
|
for optname, option in self.sections[changed_sect].items():
|
|
if '${' + changed_opt + '}' in option.value():
|
|
self._changed(changed_sect, optname)
|
|
# Options in any section and ${sectname:optname} interpolation.
|
|
for sectname, sect in self.sections.items():
|
|
for optname, option in sect.items():
|
|
if ('${' + changed_sect + ':' + changed_opt + '}' in
|
|
option.value()):
|
|
self._changed(sectname, optname)
|
|
|
|
def items(self, sectname, raw=True):
|
|
"""Get a list of (optname, value) tuples for a section.
|
|
|
|
Implemented for configparser interpolation compatbility.
|
|
|
|
Args:
|
|
sectname: The name of the section to get.
|
|
raw: Whether to get raw values. Note this parameter only exists
|
|
for ConfigParser compatibility and raw=False is not supported.
|
|
"""
|
|
items = []
|
|
if not raw:
|
|
raise ValueError("items() with raw=True is not implemented!")
|
|
for optname, option in self.sections[sectname].items():
|
|
items.append((optname, option.value()))
|
|
return items
|
|
|
|
def has_option(self, sectname, optname):
|
|
"""Check if option exists in section.
|
|
|
|
Args:
|
|
sectname: The section name.
|
|
optname: The option name
|
|
|
|
Return:
|
|
True if the option and section exist, False otherwise.
|
|
"""
|
|
if sectname not in self.sections:
|
|
return False
|
|
return optname in self.sections[sectname]
|
|
|
|
def remove_option(self, sectname, optname):
|
|
"""Remove an option.
|
|
|
|
Args:
|
|
sectname: The section where to remove an option.
|
|
optname: The option name to remove.
|
|
|
|
Return:
|
|
True if the option existed, False otherwise.
|
|
"""
|
|
try:
|
|
sectdict = self.sections[sectname]
|
|
except KeyError:
|
|
raise configexc.NoSectionError(sectname)
|
|
optname = self.optionxform(optname)
|
|
existed = optname in sectdict
|
|
if existed:
|
|
del sectdict[optname]
|
|
self.get.cache_clear()
|
|
return existed
|
|
|
|
@functools.lru_cache()
|
|
def get(self, sectname, optname, raw=False, transformed=True):
|
|
"""Get the value from a section/option.
|
|
|
|
Args:
|
|
sectname: The section to get the option from.
|
|
optname: The option name
|
|
raw: Whether to get the uninterpolated, untransformed value.
|
|
transformed: Whether the value should be transformed.
|
|
|
|
Return:
|
|
The value of the option.
|
|
"""
|
|
if not self._initialized:
|
|
raise Exception("get got called before initialisation was "
|
|
"complete!")
|
|
try:
|
|
sect = self.sections[sectname]
|
|
except KeyError:
|
|
raise configexc.NoSectionError(sectname)
|
|
try:
|
|
val = sect[optname]
|
|
except KeyError:
|
|
raise configexc.NoOptionError(optname, sectname)
|
|
if raw:
|
|
return val.value()
|
|
mapping = {key: val.value() for key, val in sect.values.items()}
|
|
newval = self._interpolation.before_get(self, sectname, optname,
|
|
val.value(), mapping)
|
|
if transformed:
|
|
newval = val.typ.transform(newval)
|
|
return newval
|
|
|
|
@cmdutils.register(name='set', instance='config',
|
|
completion=[Completion.section, Completion.option,
|
|
Completion.value])
|
|
def set_command(self, win_id: {'special': 'win_id'},
|
|
sectname: {'name': 'section'}=None,
|
|
optname: {'name': 'option'}=None, value=None, temp=False,
|
|
print_val: {'name': 'print'}=False):
|
|
"""Set an option.
|
|
|
|
If the option name ends with '?', the value of the option is shown
|
|
instead.
|
|
|
|
If the option name ends with '!' and it is a boolean value, toggle it.
|
|
|
|
//
|
|
|
|
Wrapper for self.set() to output exceptions in the status bar.
|
|
|
|
Args:
|
|
sectname: The section where the option is in.
|
|
optname: The name of the option.
|
|
value: The value to set.
|
|
temp: Set value temporarily.
|
|
print_val: Print the value after setting.
|
|
"""
|
|
if sectname is not None and optname is None:
|
|
raise cmdexc.CommandError(
|
|
"set: Either both section and option have to be given, or "
|
|
"neither!")
|
|
if sectname is None and optname is None:
|
|
tabbed_browser = objreg.get('tabbed-browser', scope='window',
|
|
window=win_id)
|
|
tabbed_browser.openurl(QUrl('qute:settings'), newtab=False)
|
|
return
|
|
|
|
if optname.endswith('?'):
|
|
optname = optname[:-1]
|
|
print_val = True
|
|
else:
|
|
try:
|
|
if optname.endswith('!') and value is None:
|
|
val = self.get(sectname, optname[:-1])
|
|
layer = 'temp' if temp else 'conf'
|
|
if isinstance(val, bool):
|
|
self.set(layer, sectname, optname[:-1], str(not val))
|
|
else:
|
|
raise cmdexc.CommandError(
|
|
"set: Attempted inversion of non-boolean value.")
|
|
elif value is not None:
|
|
layer = 'temp' if temp else 'conf'
|
|
self.set(layer, sectname, optname, value)
|
|
else:
|
|
raise cmdexc.CommandError("set: The following arguments "
|
|
"are required: value")
|
|
except (configexc.Error, configparser.Error) as e:
|
|
raise cmdexc.CommandError("set: {} - {}".format(
|
|
e.__class__.__name__, e))
|
|
|
|
if print_val:
|
|
val = self.get(sectname, optname, transformed=False)
|
|
message.info(win_id, "{} {} = {}".format(
|
|
sectname, optname, val), immediately=True)
|
|
|
|
def set(self, layer, sectname, optname, value, validate=True):
|
|
"""Set an option.
|
|
|
|
Args:
|
|
layer: A layer name as string (conf/temp/default).
|
|
sectname: The name of the section to change.
|
|
optname: The name of the option to change.
|
|
value: The new value.
|
|
validate: Whether to validate the value immediately.
|
|
"""
|
|
try:
|
|
value = self._interpolation.before_set(self, sectname, optname,
|
|
value)
|
|
except ValueError as e:
|
|
raise configexc.InterpolationSyntaxError(optname, sectname, str(e))
|
|
try:
|
|
sect = self.sections[sectname]
|
|
except KeyError:
|
|
raise configexc.NoSectionError(sectname)
|
|
mapping = {key: val.value() for key, val in sect.values.items()}
|
|
if validate:
|
|
interpolated = self._interpolation.before_get(
|
|
self, sectname, optname, value, mapping)
|
|
else:
|
|
interpolated = None
|
|
try:
|
|
sect.setv(layer, optname, value, interpolated)
|
|
except KeyError:
|
|
raise configexc.NoOptionError(optname, sectname)
|
|
else:
|
|
if self._initialized:
|
|
self._after_set(sectname, optname)
|
|
|
|
def save(self):
|
|
"""Save the config file."""
|
|
if self._configdir is None:
|
|
return
|
|
configfile = os.path.join(self._configdir, self._fname)
|
|
log.destroy.debug("Saving config to {}".format(configfile))
|
|
with qtutils.savefile_open(configfile) as f:
|
|
f.write(str(self))
|
|
|
|
def dump_userconfig(self):
|
|
"""Get the part of the config which was changed by the user.
|
|
|
|
Return:
|
|
The changed config part as string.
|
|
"""
|
|
lines = []
|
|
for sectname, sect in self.sections.items():
|
|
changed = sect.dump_userconfig()
|
|
if changed:
|
|
lines.append('[{}]'.format(sectname))
|
|
lines += ['{} = {}'.format(k, v) for k, v in changed]
|
|
if not lines:
|
|
lines = ['<Default configuration>']
|
|
return '\n'.join(lines)
|
|
|
|
def optionxform(self, val):
|
|
"""Implemented to be compatible with ConfigParser interpolation."""
|
|
return val
|
|
|
|
|
|
class SectionProxy(collections.abc.MutableMapping):
|
|
|
|
"""A proxy for a single section from a config.
|
|
|
|
Attributes:
|
|
_conf: The Config object.
|
|
_name: The section name.
|
|
"""
|
|
|
|
def __init__(self, conf, name):
|
|
"""Create a view on a section.
|
|
|
|
Args:
|
|
conf: The Config object.
|
|
name: The section name.
|
|
"""
|
|
self.conf = conf
|
|
self.name = name
|
|
|
|
def __repr__(self):
|
|
return utils.get_repr(self, name=self.name)
|
|
|
|
def __getitem__(self, key):
|
|
if not self.conf.has_option(self.name, key):
|
|
raise KeyError(key)
|
|
return self.conf.get(self.name, key)
|
|
|
|
def __setitem__(self, key, value):
|
|
return self.conf.set('conf', self.name, key, value)
|
|
|
|
def __delitem__(self, key):
|
|
if not (self.conf.has_option(self.name, key) and
|
|
self.conf.remove_option(self.name, key)):
|
|
raise KeyError(key)
|
|
|
|
def __contains__(self, key):
|
|
return self.conf.has_option(self.name, key)
|
|
|
|
def __len__(self):
|
|
return len(self._options())
|
|
|
|
def __iter__(self):
|
|
return self._options().__iter__()
|
|
|
|
def _options(self):
|
|
"""Get the option keys from this section."""
|
|
return self.conf.sections[self.name].keys()
|
|
|
|
def get(self, optname, *, raw=False): # pylint: disable=arguments-differ
|
|
"""Get a value from this section.
|
|
|
|
We deliberately don't support the default argument here, but have a raw
|
|
argument instead.
|
|
|
|
Args:
|
|
optname: The option name to get.
|
|
raw: Whether to get a raw value or not.
|
|
"""
|
|
return self.conf.get(self.name, optname, raw=raw)
|