sopel/config/__init__.py
2017-11-22 19:26:40 -05:00

264 lines
9.6 KiB
Python
Executable File

# coding=utf-8
"""
The config object provides a simplified to access Sopel's configuration file.
The sections of the file are attributes of the object, and the keys in the
section are attributes of that. So, for example, the ``eggs`` attribute in the
``[spam]`` section can be accessed from ``config.spam.eggs``.
Section definitions (see "Section configuration sections" below) can be added
to the config object with ``define_section``. When this is done, only the
defined keys will be available. A section can not be given more than one
definition. The ``[core]`` section is defined with ``CoreSection`` when the
object is initialized.
.. versionadded:: 6.0.0
"""
# Copyright 2012-2015, Elsie Powell, embolalia.com
# Copyright © 2012, Elad Alfassa <elad@fedoraproject.org>
# Licensed under the Eiffel Forum License 2.
from __future__ import unicode_literals, absolute_import, print_function, division
from tools import iteritems, stderr
import tools
from tools import get_input
import loader
import os
import sys
if sys.version_info.major < 3:
import ConfigParser
else:
basestring = str
import configparser as ConfigParser
import config.core_section
from config.types import StaticSection
class ConfigurationError(Exception):
""" Exception type for configuration errors """
def __init__(self, value):
self.value = value
def __str__(self):
return 'ConfigurationError: %s' % self.value
class Config(object):
def __init__(self, filename, validate=True):
"""The bot's configuration.
The given filename will be associated with the configuration, and is
the file which will be written if write() is called. If load is not
given or True, the configuration object will load the attributes from
the file at filename.
A few default values will be set here if they are not defined in the
config file, or a config file is not loaded. They are documented below.
"""
self.filename = filename
"""The config object's associated file, as noted above."""
self.parser = ConfigParser.RawConfigParser(allow_no_value=True)
self.parser.read(self.filename)
self.define_section('core', config.core_section.CoreSection,
validate=validate)
self.get = self.parser.get
@property
def homedir(self):
"""An alias to config.core.homedir"""
# Technically it's the other way around, so we can bootstrap filename
# attributes in the core section, but whatever.
configured = None
if self.parser.has_option('core', 'homedir'):
configured = self.parser.get('core', 'homedir')
if configured:
return configured
else:
return os.path.dirname(self.filename)
def save(self):
"""Save all changes to the config file."""
cfgfile = open(self.filename, 'w')
self.parser.write(cfgfile)
cfgfile.flush()
cfgfile.close()
def add_section(self, name):
"""Add a section to the config file.
Returns ``False`` if already exists.
"""
try:
return self.parser.add_section(name)
except ConfigParser.DuplicateSectionError:
return False
def define_section(self, name, cls_, validate=True):
"""Define the available settings in a section.
``cls_`` must be a subclass of ``StaticSection``. If the section has
already been defined with a different class, ValueError is raised.
If ``validate`` is True, the section's values will be validated, and an
exception raised if they are invalid. This is desirable in a module's
setup function, for example, but might not be in the configure function.
"""
if not issubclass(cls_, StaticSection):
raise ValueError("Class must be a subclass of StaticSection.")
current = getattr(self, name, None)
current_name = str(current.__class__)
new_name = str(cls_)
if (current is not None and not isinstance(current, self.ConfigSection)
and not current_name == new_name):
raise ValueError(
"Can not re-define class for section from {} to {}.".format(
current_name, new_name)
)
setattr(self, name, cls_(self, name, validate=validate))
class ConfigSection(object):
"""Represents a section of the config file.
Contains all keys in thesection as attributes.
"""
def __init__(self, name, items, parent):
object.__setattr__(self, '_name', name)
object.__setattr__(self, '_parent', parent)
for item in items:
value = item[1].strip()
if not value.lower() == 'none':
if value.lower() == 'false':
value = False
object.__setattr__(self, item[0], value)
def __getattr__(self, name):
return None
def __setattr__(self, name, value):
object.__setattr__(self, name, value)
if type(value) is list:
value = ','.join(value)
self._parent.parser.set(self._name, name, value)
def get_list(self, name):
value = getattr(self, name)
if not value:
return []
if isinstance(value, basestring):
value = value.split(',')
# Keep the split value, so we don't have to keep doing this
setattr(self, name, value)
return value
def __getattr__(self, name):
if name in self.parser.sections():
items = self.parser.items(name)
section = self.ConfigSection(name, items, self) # Return a section
setattr(self, name, section)
return section
else:
raise AttributeError("%r object has no attribute %r"
% (type(self).__name__, name))
def option(self, question, default=False):
"""Ask "y/n" and return the corresponding boolean answer.
Show user in terminal a "y/n" prompt, and return true or false based on
the response. If default is passed as true, the default will be shown
as ``[y]``, else it will be ``[n]``. ``question`` should be phrased as
a question, but without a question mark at the end.
"""
d = 'n'
if default:
d = 'y'
ans = get_input(question + ' (y/n)? [' + d + '] ')
if not ans:
ans = d
return ans.lower() == 'y'
def _modules(self):
home = os.getcwd()
modules_dir = os.path.join(home, 'modules')
filenames = sopel.loader.enumerate_modules(self)
os.sys.path.insert(0, modules_dir)
for name, mod_spec in iteritems(filenames):
path, type_ = mod_spec
try:
module, _ = sopel.loader.load_module(name, path, type_)
except Exception as e:
filename, lineno = sopel.tools.get_raising_file_and_line()
rel_path = os.path.relpath(filename, os.path.dirname(__file__))
raising_stmt = "%s:%d" % (rel_path, lineno)
stderr("Error loading %s: %s (%s)" % (name, e, raising_stmt))
else:
if hasattr(module, 'configure'):
prompt = name + ' module'
if module.__doc__:
doc = module.__doc__.split('\n', 1)[0]
if doc:
prompt = doc
prompt = 'Configure {} (y/n)? [n]'.format(prompt)
do_configure = get_input(prompt)
do_configure = do_configure and do_configure.lower() == 'y'
if do_configure:
module.configure(self)
self.save()
def _wizard(section, config=None):
dotdir = os.path.expanduser('~/.sopel')
configpath = os.path.join(dotdir, (config or 'default') + '.cfg')
if section == 'all':
_create_config(configpath)
elif section == 'mod':
_check_dir(False)
if not os.path.isfile(configpath):
print("No config file found." +
" Please make one before configuring these options.")
sys.exit(1)
config = Config(configpath, validate=False)
config._modules()
def _check_dir(create=True):
dotdir = os.path.join(os.path.expanduser('~'), '.sopel')
if not os.path.isdir(dotdir):
if create:
print('Creating a config directory at ~/.sopel...')
try:
os.makedirs(dotdir)
except Exception as e:
print('There was a problem creating %s:' % dotdir, file=sys.stderr)
print('%s, %s' % (e.__class__, str(e)), file=sys.stderr)
print('Please fix this and then run Sopel again.', file=sys.stderr)
sys.exit(1)
else:
print("No config file found. Please make one before configuring these options.")
sys.exit(1)
def _create_config(configpath):
_check_dir()
print("Please answer the following questions" +
" to create your configuration file:\n")
try:
config = Config(configpath, validate=False)
sopel.config.core_section.configure(config)
if config.option(
'Would you like to see if there are any modules'
' that need configuring'
):
config._modules()
config.save()
except Exception:
print("Encountered an error while writing the config file." +
" This shouldn't happen. Check permissions.")
raise
sys.exit(1)
print("Config file written sucessfully!")