artin/cement
1
0
Fork 0
mirror of https://github.com/datafolklabs/cement.git synced 2026-02-06 14:26:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Partially Resolves Issue #192

Browse Source
This commit is contained in:
BJ Dierkes 2017-02-05 04:00:49 -06:00
parent 89b8b9c05b
commit 16781bf1c6
37 changed files with 539 additions and 1060 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -38,9 +38,12 @@ Refactoring:
Incompatible:
* ``[core]`` Replace Interfaces with ABC Base Classes
* :issue:`192`
* ``[core.foundation]`` Rename ``CementApp`` to ``App``.
* ``[core.hook]`` Drop deprecated backend globals
* ``[core.handler]`` Rename ``CementBaseHandler`` to ``Handler``
* ``[core.handler]`` Drop deprecated backend globals
* ``[core.hook]`` Drop deprecated backend globals
* ``[core.controller]`` Drop ``CementBaseController``
* ``[ext.configobj]`` No longer shipped with Cement.
* ``[ext.json_configobj]`` No longer shipped with Cement.

78
cement/core/arg.py
View File

@ -3,71 +3,41 @@ Cement core argument module.
"""
from ..core import interface
from ..core.handler import CementBaseHandler
from abc import abstractmethod
from ..core.handler import Handler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
# pylint: disable=w0613
def argument_validator(klass, obj):
"""Validates a handler implementation against the IArgument interface."""
members = [
'_setup',
'parse',
'add_argument',
]
interface.validate(IArgument, obj, members)
# pylint: disable=W0105,W0232,W0232,R0903,E0213,R0923
class IArgument(interface.Interface):
class ArgumentHandlerBase(Handler):
"""
This class defines the Argument Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
below. Implementations do *not* subclass from interfaces.
implement this interface must provide the methods and attributes defined
below.
Example:
.. code-block:: python
from cement.core import interface, arg
from cement.core.arg import ArgumentHandlerBase
class MyArgumentHandler(arg.CementArgumentHandler):
class MyArgumentHandler(ArgumentHandlerBase):
class Meta:
interface = arg.IArgument
label = 'my_argument_handler'
"""
class IMeta:
class Meta:
"""Interface meta-data options."""
label = 'argument'
#: The string identifier of the interface.
interface = 'argument'
"""The string identifier of the interface."""
validator = argument_validator
"""Interface validator function."""
# Must be provided by the implementation
Meta = interface.Attribute('Handler Meta-data')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object
:returns: ``None``
"""
# pylint: disable=E0211
def add_argument(*args, **kw):
@abstractmethod
def add_argument(self, *args, **kw):
"""
Add arguments for parsing. This should be -o/--option or positional.
Note that the interface defines the following parameters so that at
@ -90,7 +60,9 @@ class IArgument(interface.Interface):
:returns: ``None``
"""
pass
@abstractmethod
def parse(arg_list):
"""
Parse the argument list (i.e. sys.argv). Can return any object as
@ -102,25 +74,11 @@ class IArgument(interface.Interface):
:returns: Callable object
"""
pass
# pylint: disable=W0105
class CementArgumentHandler(CementBaseHandler):
class ArgumentHandler(ArgumentHandlerBase):
"""Base class that all Argument Handlers should sub-class from."""
"""Argument handler implementation"""
class Meta:
"""
Handler meta-data (can be passed as keyword arguments to the parent
class).
"""
label = None
"""The string identifier of the handler implementation."""
interface = IArgument
"""The interface that this class implements."""
def __init__(self, *args, **kw):
super(CementArgumentHandler, self).__init__(*args, **kw)
pass

87
cement/core/cache.py
View File

@ -1,72 +1,41 @@
"""Cement core cache module."""
from ..core import interface, handler
from abc import abstractmethod
from ..core.handler import Handler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
def cache_validator(klass, obj):
"""Validates a handler implementation against the ICache interface."""
members = [
'_setup',
'get',
'set',
'delete',
'purge',
]
interface.validate(ICache, obj, members)
class ICache(interface.Interface):
class CacheHandlerBase(Handler):
"""
This class defines the Cache Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
implement this interface must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core import cache
from cement.core.cache import CacheHandlerBase
class MyCacheHandler(object):
class MyCacheHandler(CacheHandlerBase):
class Meta:
interface = cache.ICache
label = 'my_cache_handler'
...
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
"""Interface meta-data."""
class Meta:
label = 'cache'
"""The label (or type identifier) of the interface."""
"""Handler meta-data."""
validator = cache_validator
"""Interface validator function."""
#: The string identifier of the interface.
interface = 'cache'
# Must be provided by the implementation
Meta = interface.Attribute('Handler meta-data')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
:returns: ``None``
"""
def get(key, fallback=None):
@abstractmethod
def get(self, key, fallback=None):
"""
Get the value for a key in the cache. If the key does not exist
or the key/value in cache is expired, this functions must return
@ -78,8 +47,10 @@ class ICache(interface.Interface):
:returns: Unknown (whatever the value is in cache, or the `fallback`)
"""
pass
def set(key, value, time=None):
@abstractmethod
def set(self, key, value, time=None):
"""
Set the key/value in the cache for a set amount of `time`.
@ -91,8 +62,10 @@ class ICache(interface.Interface):
:returns: ``None``
"""
pass
def delete(key):
@abstractmethod
def delete(self, key):
"""
Deletes a key/value from the cache.
@ -101,33 +74,21 @@ class ICache(interface.Interface):
:rtype: ``boolean``
"""
pass
# pylint: disable=E0211
@abstractmethod
def purge():
"""
Clears all data from the cache.
"""
pass
class CementCacheHandler(handler.CementBaseHandler):
class CacheHandler(CacheHandlerBase):
"""
Base class that all Cache Handlers should sub-class from.
Cache handler implementation.
"""
class Meta:
"""
Handler meta-data (can be passed as keyword arguments to the parent
class).
"""
label = None
"""String identifier of this handler implementation."""
interface = ICache
"""The interface that this handler class implements."""
def __init__(self, *args, **kw):
super(CementCacheHandler, self).__init__(*args, **kw)
pass

125
cement/core/config.py
View File

@ -1,85 +1,43 @@
"""Cement core config module."""
import os
from ..core import interface, handler
from abc import ABC, abstractmethod, abstractproperty
from ..core.handler import Handler
from ..utils.fs import abspath
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
def config_validator(klass, obj):
"""Validates a handler implementation against the IConfig interface."""
members = [
'_setup',
'keys',
'get_sections',
'get_section_dict',
'get',
'set',
'parse_file',
'merge',
'add_section',
'has_section',
]
interface.validate(IConfig, obj, members)
class IConfig(interface.Interface):
class ConfigHandlerBase(Handler):
"""
This class defines the Config Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
implement this interface must provide the methods and attributes defined
below.
All implementations must provide sane 'default' functionality when
instantiated with no arguments. Meaning, it can and should accept
optional parameters that alter how it functions, but can not require
any parameters. When the framework first initializes handlers it does
not pass anything too them, though a handler can be instantiated first
(with or without parameters) and then passed to ``App()`` already
instantiated.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core import config
from cement.core.config import ConfigHandlerBase
class MyConfigHandler(config.CementConfigHandler):
class MyConfigHandler(ConfigHandlerbase):
class Meta:
interface = config.IConfig
label = 'my_config_handler'
label = 'my_config'
...
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
"""Interface meta-data."""
label = 'config'
class Meta:
"""Handler meta-data."""
interface = 'config'
"""The string identifier of the interface."""
validator = config_validator
"""The validator function."""
# Must be provided by the implementation
Meta = interface.Attribute('Handler Meta-data')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
:returns: None
"""
def parse_file(file_path):
@abstractmethod
def parse_file(self, file_path):
"""
Parse config file settings from file_path. Returns True if the file
existed, and was parsed successfully. Returns False otherwise.
@ -89,8 +47,10 @@ class IConfig(interface.Interface):
:rtype: ``boolean``
"""
pass
def keys(section):
@abstractmethod
def keys(self, section):
"""
Return a list of configuration keys from `section`.
@ -99,8 +59,10 @@ class IConfig(interface.Interface):
:rtype: ``list``
"""
pass
def get_sections():
@abstractmethod
def get_sections(self):
"""
Return a list of configuration sections. These are designated by a
[block] label in a config file.
@ -109,8 +71,10 @@ class IConfig(interface.Interface):
:rtype: ``list``
"""
pass
def get_section_dict(section):
@abstractmethod
def get_section_dict(self, section):
"""
Return a dict of configuration parameters for [section].
@ -120,8 +84,10 @@ class IConfig(interface.Interface):
:rtype: ``dict``
"""
pass
def add_section(section):
@abstractmethod
def add_section(self, section):
"""
Add a new section if it doesn't exist.
@ -129,8 +95,10 @@ class IConfig(interface.Interface):
:returns: ``None``
"""
pass
def get(section, key):
@abstractmethod
def get(self, section, key):
"""
Return a configuration value based on [section][key]. The return
value type is unknown.
@ -142,8 +110,10 @@ class IConfig(interface.Interface):
:rtype: ``Unknown``
"""
pass
def set(section, key, value):
@abstractmethod
def set(self, section, key, value):
"""
Set a configuration value based at [section][key].
@ -154,8 +124,10 @@ class IConfig(interface.Interface):
:returns: ``None``
"""
pass
def merge(dict_obj, override=True):
@abstractmethod
def merge(self, dict_obj, override=True):
"""
Merges a dict object into the configuration.
@ -164,8 +136,10 @@ class IConfig(interface.Interface):
Default: True
:returns: ``None``
"""
pass
def has_section(section):
@abstractmethod
def has_section(self, section):
"""
Returns whether or not the section exists.
@ -173,30 +147,17 @@ class IConfig(interface.Interface):
:returns: ``boolean``
"""
pass
class CementConfigHandler(handler.CementBaseHandler):
class ConfigHandler(ConfigHandlerBase):
"""
Base class that all Config Handlers should sub-class from.
Config handler implementation.
"""
class Meta:
"""
Handler meta-data (can be passed as keyword arguments to the parent
class).
"""
label = None
"""The string identifier of the implementation."""
interface = IConfig
"""The interface that this handler implements."""
def __init__(self, *args, **kw):
super(CementConfigHandler, self).__init__(*args, **kw)
@abstractmethod
def _parse_file(self, file_path):
"""
Parse a configuration file at `file_path` and store it. This function
@ -208,7 +169,7 @@ class CementConfigHandler(handler.CementBaseHandler):
:rtype: ``boolean``
"""
raise NotImplementedError
pass
def parse_file(self, file_path):
"""

131
cement/core/controller.py
View File

@ -3,108 +3,88 @@
import re
import textwrap
import argparse
from ..core import exc, interface, handler
from abc import abstractmethod
from ..core import exc
from ..core.handler import Handler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
def controller_validator(klass, obj):
"""
Validates a handler implementation against the IController interface.
# def controller_validator(klass, obj):
# """
# Validates a handler implementation against the IController interface.
"""
members = [
'_setup',
'_dispatch',
]
meta = [
'label',
'interface',
'config_section',
'config_defaults',
'stacked_on',
'stacked_type',
]
interface.validate(IController, obj, members, meta=meta)
# """
# members = [
# '_setup',
# '_dispatch',
# ]
# meta = [
# 'label',
# 'interface',
# 'config_section',
# 'config_defaults',
# 'stacked_on',
# 'stacked_type',
# ]
# interface.validate(IController, obj, members, meta=meta)
# also check _meta.arguments values
errmsg = "Controller arguments must be a list of tuples. I.e. " + \
"[ (['-f', '--foo'], dict(action='store')), ]"
# # also check _meta.arguments values
# errmsg = "Controller arguments must be a list of tuples. I.e. " + \
# "[ (['-f', '--foo'], dict(action='store')), ]"
if obj._meta.arguments is not None:
if type(obj._meta.arguments) is not list:
raise exc.InterfaceError(errmsg)
for item in obj._meta.arguments:
if type(item) is not tuple:
raise exc.InterfaceError(errmsg)
if type(item[0]) is not list:
raise exc.InterfaceError(errmsg)
if type(item[1]) is not dict:
raise exc.InterfaceError(errmsg)
# if obj._meta.arguments is not None:
# if type(obj._meta.arguments) is not list:
# raise exc.InterfaceError(errmsg)
# for item in obj._meta.arguments:
# if type(item) is not tuple:
# raise exc.InterfaceError(errmsg)
# if type(item[0]) is not list:
# raise exc.InterfaceError(errmsg)
# if type(item[1]) is not dict:
# raise exc.InterfaceError(errmsg)
if not obj._meta.label == 'base' and obj._meta.stacked_on is None:
errmsg = "Controller `%s` is not stacked anywhere!" % \
obj.__class__.__name__
raise exc.InterfaceError(errmsg)
if not obj._meta.label == 'base' and \
obj._meta.stacked_type not in ['nested', 'embedded']:
raise exc.InterfaceError(
"Controller '%s' " % obj._meta.label +
"has an unknown stacked type of '%s'." %
obj._meta.stacked_type
)
# if not obj._meta.label == 'base' and obj._meta.stacked_on is None:
# errmsg = "Controller `%s` is not stacked anywhere!" % \
# obj.__class__.__name__
# raise exc.InterfaceError(errmsg)
# if not obj._meta.label == 'base' and \
# obj._meta.stacked_type not in ['nested', 'embedded']:
# raise exc.InterfaceError(
# "Controller '%s' " % obj._meta.label +
# "has an unknown stacked type of '%s'." %
# obj._meta.stacked_type
# )
class IController(interface.Interface):
class ControllerHandlerBase(Handler):
"""
This class defines the Controller Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
implement this interface must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core.handler import Handler
from cement.core.controller import IController
from cement.core.controller import ControllerHandlerBase
class MyController(handler):
class MyController(ControllerHandlerBase):
class Meta:
interface = controller.IController
label = 'my_controller'
...
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
class Meta:
"""Interface meta-data."""
#: The string identifier of the interface.
label = 'controller'
#: The interface validator function.
validator = controller_validator
# Must be provided by the implementation
Meta = interface.Attribute('Handler meta-data')
def _setup(app_obj):
"""
The _setup function is after application initialization and after it
is determined that this controller was requested via command line
arguments. Meaning, a controllers _setup() function is only called
right before it's _dispatch() function is called to execute a command.
Must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
:returns: ``None``
"""
interface = 'controller'
@abstractmethod
def _dispatch(self):
"""
Reads the application object's data to dispatch a command from this
@ -119,5 +99,10 @@ class IController(interface.Interface):
or ``None`` if no controller function is called.
"""
pass
class ControllerHandler(ControllerHandlerBase):
"""Controller handler implementation."""
pass

71
cement/core/extension.py
View File

@ -1,42 +1,28 @@
"""Cement core extensions module."""
import sys
from ..core import exc, interface, handler
from abc import ABC, abstractmethod, abstractproperty
from ..core import exc
from ..core.handler import Handler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
def extension_validator(klass, obj):
"""
Validates an handler implementation against the IExtension interface.
"""
members = [
'_setup',
'load_extension',
'load_extensions',
'get_loaded_extensions',
]
interface.validate(IExtension, obj, members)
class IExtension(interface.Interface):
class ExtensionHandlerBase(Handler):
"""
This class defines the Extension Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core import extension
from cement.core.extension import ExtensionHandlerBase
class MyExtensionHandler(object):
class MyExtensionHandler(ExtensionHandlerBase):
class Meta:
interface = extension.IExtension
label = 'my_extension_handler'
@ -44,31 +30,14 @@ class IExtension(interface.Interface):
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
class Meta:
"""Interface meta-data."""
"""Handler meta-data."""
label = 'extension'
"""The string identifier of the interface."""
validator = extension_validator
"""The interface validator function."""
# Must be provided by the implementation
Meta = interface.Attribute('Handler Meta-data class')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
:returns: None
"""
#: The string identifier of the interface.
interface = 'extension'
@abstractmethod
def load_extension(self, ext_module):
"""
Load an extension whose module is 'ext_module'. For example,
@ -78,7 +47,9 @@ class IExtension(interface.Interface):
:type ext_module: ``str``
"""
pass
@abstractmethod
def load_extensions(self, ext_list):
"""
Load all extensions from ext_list.
@ -89,9 +60,10 @@ class IExtension(interface.Interface):
:type ext_list: ``list``
"""
pass
class CementExtensionHandler(handler.CementBaseHandler):
class ExtensionHandler(ExtensionHandlerBase):
class Meta:
@ -100,24 +72,23 @@ class CementExtensionHandler(handler.CementBaseHandler):
class).
"""
interface = IExtension
"""The interface that this class implements."""
label = 'cement'
"""The string identifier of the handler."""
def __init__(self, **kw):
"""
This is an implementation of the IExtentionHandler interface. It
handles loading framework extensions.
This handler defines the Extention Interface, which handles
loading framework extensions. All extension handlers should
sub-class from here, or ensure that their implementation meets the
requirements of this base class.
"""
super(CementExtensionHandler, self).__init__(**kw)
super().__init__(**kw)
self.app = None
self._loaded_extensions = []
def get_loaded_extensions(self):
"""Returns list of loaded extensions."""
"""Returns a list of loaded extensions."""
return self._loaded_extensions
def load_extension(self, ext_module):

41
cement/core/foundation.py
View File

@ -396,42 +396,42 @@ class App(meta.MetaMixin):
config_handler = 'configparser'
"""
A handler class that implements the IConfig interface.
A handler class that implements the Config interface.
"""
mail_handler = 'dummy'
"""
A handler class that implements the IMail interface.
A handler class that implements the Mail interface.
"""
extension_handler = 'cement'
"""
A handler class that implements the IExtension interface.
A handler class that implements the Extension interface.
"""
log_handler = 'logging'
"""
A handler class that implements the ILog interface.
A handler class that implements the Log interface.
"""
plugin_handler = 'cement'
"""
A handler class that implements the IPlugin interface.
A handler class that implements the Plugin interface.
"""
argument_handler = 'argparse'
"""
A handler class that implements the IArgument interface.
A handler class that implements the Argument interface.
"""
output_handler = 'dummy'
"""
A handler class that implements the IOutput interface.
A handler class that implements the Output interface.
"""
cache_handler = None
"""
A handler class that implements the ICache interface.
A handler class that implements the Cache interface.
"""
base_controller = None
@ -1049,23 +1049,23 @@ class App(meta.MetaMixin):
self.hook.register(*hook_spec)
# define and register handlers
self.handler.define(extension.IExtension)
self.handler.define(log.ILog)
self.handler.define(config.IConfig)
self.handler.define(mail.IMail)
self.handler.define(plugin.IPlugin)
self.handler.define(output.IOutput)
self.handler.define(arg.IArgument)
self.handler.define(controller.IController)
self.handler.define(cache.ICache)
self.handler.define(extension.ExtensionHandlerBase)
self.handler.define(log.LogHandlerBase)
self.handler.define(config.ConfigHandlerBase)
self.handler.define(mail.MailHandlerBase)
self.handler.define(plugin.PluginHandlerBase)
self.handler.define(output.OutputHandlerBase)
self.handler.define(arg.ArgumentHandlerBase)
self.handler.define(controller.ControllerHandlerBase)
self.handler.define(cache.CacheHandlerBase)
# define application handlers
for interface_class in self._meta.define_handlers:
self.handler.define(interface_class)
for handler_class in self._meta.define_handlers:
self.handler.define(handler_class)
# extension handler is the only thing that can't be loaded... as,
# well, an extension. ;)
self.handler.register(extension.CementExtensionHandler)
self.handler.register(extension.ExtensionHandler)
# register application handlers
for handler_class in self._meta.handlers:
@ -1151,6 +1151,7 @@ class App(meta.MetaMixin):
self._meta.config_handler)
if self._meta.config_section is None:
self._meta.config_section = self._meta.label
self.config.add_section(self._meta.config_section)
if self._meta.config_defaults is not None:

249
cement/core/handler.py
View File

@ -4,12 +4,101 @@ Cement core handler module.
"""
import re
from abc import ABC, abstractproperty
from ..core import exc, meta
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
class Handler(ABC, meta.MetaMixin):
"""Base handler class that all Cement Handlers should subclass from."""
class Meta:
"""
Handler meta-data (can also be passed as keyword arguments to the
parent class).
"""
"""The string identifier of this handler."""
label = None
interface = None
"""The interface that this class implements."""
config_section = None
"""
A config [section] to merge config_defaults with.
Note: Though Meta.config_section defaults to None, Cement will
set this to the value of ``<interface_label>.<handler_label>`` if
no section is set by the user/developer.
"""
config_defaults = None
"""
A config dictionary that is merged into the applications config
in the ``[<config_section>]`` block. These are defaults and do not
override any existing defaults under that section.
"""
overridable = False
"""
Whether or not handler can be overridden by
``App.Meta.handler_override_options``. Will be listed as an
available choice to override the specific handler (i.e.
``App.Meta.output_handler``, etc).
"""
def __init__(self, **kw):
super(Handler, self).__init__(**kw)
try:
assert self._meta.label, \
"%s.Meta.label undefined." % self.__class__.__name__
assert self._meta.interface, \
"%s.Meta.interface undefined." % self.__class__.__name__
except AssertionError as e:
raise(exc.FrameworkError(e.args[0]))
self.app = None
def _setup(self, app):
"""
The _setup function is called during application initialization and
must ``setup`` the handler object making it ready for the framework
or the application to make further calls to it.
:param app: The application object.
:returns: None
"""
self.app = app
if self._meta.config_section is None:
self._meta.config_section = "%s.%s" % \
(self._meta.interface, self._meta.label)
if self._meta.config_defaults is not None:
LOG.debug("merging config defaults from '%s' " % self +
"into section '%s'" % self._meta.config_section)
dict_obj = dict()
dict_obj[self._meta.config_section] = self._meta.config_defaults
self.app.config.merge(dict_obj, override=False)
self._validate()
def _validate(self):
"""
Perform any validation to ensure proper data, meta-data, etc.
"""
pass
class HandlerManager(object):
"""
Manages the handler system to define, get, resolve, etc handlers with
@ -97,13 +186,11 @@ class HandlerManager(object):
"""
return self.__handlers__.keys()
def define(self, interface):
def define(self, handler):
"""
Define a handler based on the provided interface. Defines a handler
type based on ``<interface>.IMeta.label``.
Define an interface based on the provided handler.
:param interface: The interface class that defines the interface to be
implemented by handlers.
:param handler: The handler that defines the interface implementation
:raises: :class:`cement.core.exc.InterfaceError`
:raises: :class:`cement.core.exc.FrameworkError`
@ -111,24 +198,19 @@ class HandlerManager(object):
.. code-block:: python
app.handler.define(IDatabaseHandler)
app.handler.define(DatabaseHandler)
"""
if not hasattr(interface, 'IMeta'):
raise exc.InterfaceError("Invalid %s, " % interface +
"missing 'IMeta' class.")
if not hasattr(interface.IMeta, 'label'):
raise exc.InterfaceError("Invalid %s, " % interface +
"missing 'IMeta.label' class.")
LOG.debug("defining handler type '%s' (%s)" %
(interface.IMeta.label, interface.__name__))
LOG.debug("defining handler interface '%s' (%s)" %
(handler.Meta.interface, handler.__name__))
if interface.IMeta.label in self.__handlers__:
raise exc.FrameworkError("Handler type '%s' already defined!" %
interface.IMeta.label)
self.__handlers__[interface.IMeta.label] = {
'__interface__': interface
if handler.Meta.interface in self.__handlers__:
msg = "Handler interface '%s' already defined!" % \
handler.Meta.interface
raise exc.FrameworkError(msg)
self.__handlers__[handler.Meta.interface] = {
'__interface__': handler
}
def defined(self, handler_type):
@ -152,14 +234,14 @@ class HandlerManager(object):
else:
return False
def register(self, handler_obj, force=False):
def register(self, handler_class, force=False):
"""
Register a handler object to a handler. If the same object is already
registered then no exception is raised, however if a different object
attempts to be registered to the same name a ``FrameworkError`` is
raised.
Register a handler class to an interface. If the same object is
already registered then no exception is raised, however if a different
object attempts to be registered to the same name a ``FrameworkError``
is raised.
:param handler_obj: The uninstantiated handler object to register.
:param handler_class: The uninstantiated handler class to register.
:param force: Whether to allow replacement if an existing
handler of the same ``label`` is already registered.
:raises: :class:`cement.core.exc.InterfaceError`
@ -181,52 +263,47 @@ class HandlerManager(object):
"""
orig_obj = handler_obj
# for checks
obj = orig_obj()
if not issubclass(handler_class, Handler):
raise exc.InterfaceError("Class %s " % handler_class +
"does not implement Handler")
if not hasattr(obj._meta, 'label') or not obj._meta.label:
raise exc.InterfaceError("Invalid handler %s, " % orig_obj +
"missing '_meta.label'.")
if not hasattr(obj._meta, 'interface') or not obj._meta.interface:
raise exc.InterfaceError("Invalid handler %s, " % orig_obj +
"missing '_meta.interface'.")
obj = handler_class()
# translate dashes to underscores
orig_obj.Meta.label = re.sub('-', '_', obj._meta.label)
handler_class.Meta.label = re.sub('-', '_', obj._meta.label)
obj._meta.label = re.sub('-', '_', obj._meta.label)
handler_type = obj._meta.interface.IMeta.label
interface = obj._meta.interface
LOG.debug("registering handler '%s' into handlers['%s']['%s']" %
(orig_obj, handler_type, obj._meta.label))
(handler_class, interface, obj._meta.label))
if handler_type not in self.__handlers__:
raise exc.FrameworkError("Handler type '%s' doesn't exist." %
handler_type)
if obj._meta.label in self.__handlers__[handler_type] and \
self.__handlers__[handler_type][obj._meta.label] != orig_obj:
if interface not in self.__handlers__:
raise exc.FrameworkError("Handler interface '%s' doesn't exist." %
interface)
if obj._meta.label in self.__handlers__[interface] and \
self.__handlers__[interface][obj._meta.label] != handler_class:
if force is True:
LOG.debug(
"handlers['%s']['%s'] already exists" %
(handler_type, obj._meta.label) +
(interface, obj._meta.label) +
", but `force==True`"
)
else:
raise exc.FrameworkError(
"handlers['%s']['%s'] already exists" %
(handler_type, obj._meta.label)
(interface, obj._meta.label)
)
interface = self.__handlers__[handler_type]['__interface__']
if hasattr(interface.IMeta, 'validator'):
interface.IMeta().validator(obj)
else:
LOG.debug("Interface '%s' does not have a validator() function!" %
interface)
interface_class = self.__handlers__[interface]['__interface__']
self.__handlers__[handler_type][obj._meta.label] = orig_obj
if not issubclass(handler_class, interface_class):
raise exc.InterfaceError("Handler %s " % handler_class.__name__ +
"does not sub-class %s" % \
interface_class.__name__)
self.__handlers__[interface][obj._meta.label] = handler_class
def registered(self, handler_type, handler_label):
"""
@ -305,73 +382,3 @@ class HandlerManager(object):
elif han is None:
LOG.debug(msg)
return None
class CementBaseHandler(meta.MetaMixin):
"""Base handler class that all Cement Handlers should subclass from."""
class Meta:
"""
Handler meta-data (can also be passed as keyword arguments to the
parent class).
"""
label = None
"""The string identifier of this handler."""
interface = None
"""The interface that this class implements."""
config_section = None
"""
A config [section] to merge config_defaults with.
Note: Though Meta.config_section defaults to None, Cement will
set this to the value of ``<interface_label>.<handler_label>`` if
no section is set by the user/developer.
"""
config_defaults = None
"""
A config dictionary that is merged into the applications config
in the ``[<config_section>]`` block. These are defaults and do not
override any existing defaults under that section.
"""
overridable = False
"""
Whether or not handler can be overridden by
``App.Meta.handler_override_options``. Will be listed as an
available choice to override the specific handler (i.e.
``App.Meta.output_handler``, etc).
"""
def __init__(self, **kw):
super(CementBaseHandler, self).__init__(**kw)
self.app = None
def _setup(self, app_obj):
"""
The _setup function is called during application initialization and
must ``setup`` the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
:returns: None
"""
self.app = app_obj
if self._meta.config_section is None:
self._meta.config_section = "%s.%s" % \
(self._meta.interface.IMeta.label, self._meta.label)
if self._meta.config_defaults is not None:
LOG.debug("merging config defaults from '%s' " % self +
"into section '%s'" % self._meta.config_section)
dict_obj = dict()
dict_obj[self._meta.config_section] = self._meta.config_defaults
self.app.config.merge(dict_obj, override=False)

69
cement/core/interface.py
View File

@ -1,69 +0,0 @@
"""
Cement core interface module.
"""
from ..core import exc, backend
DEFAULT_META = ['interface', 'label', 'config_defaults', 'config_section']
class Interface(object):
"""
An interface definition class. All Interfaces should subclass from
here. Note that this is not an implementation and should never be
used directly.
"""
def __init__(self):
raise exc.InterfaceError("Interfaces can not be used directly.")
class Attribute(object):
"""
An interface attribute definition.
:param description: The description of the attribute.
"""
def __init__(self, description):
self.description = description
def __repr__(self):
return "<interface.Attribute - '%s'>" % self.description
def validate(interface, obj, members=[], meta=DEFAULT_META):
"""
A wrapper to validate interfaces.
:param interface: The interface class to validate against
:param obj: The object to validate.
:param members: The object members that must exist.
:param meta: The meta object members that must exist.
:raises: cement.core.exc.InterfaceError
"""
invalid = []
if hasattr(obj, '_meta') and interface != obj._meta.interface:
raise exc.InterfaceError("%s does not implement %s." %
(obj, interface))
for member in members:
if not hasattr(obj, member):
invalid.append(member)
if not hasattr(obj, '_meta'):
invalid.append("_meta")
else:
for member in meta:
if not hasattr(obj._meta, member):
invalid.append("_meta.%s" % member)
if invalid:
raise exc.InterfaceError("Invalid or missing: %s in %s" %
(invalid, obj))

92
cement/core/log.py
View File

@ -3,82 +3,52 @@ Cement core log module.
"""
from ..core import interface, handler
# from ..core import interface
from abc import ABC, abstractmethod, abstractproperty
from ..core.handler import Handler
def log_validator(klass, obj):
"""Validates an handler implementation against the ILog interface."""
members = [
'_setup',
'set_level',
'get_level',
'info',
'warning',
'error',
'fatal',
'debug',
]
interface.validate(ILog, obj, members)
class ILog(interface.Interface):
class LogHandlerBase(Handler):
"""
This class defines the Log Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core import log
from cement.core.log import LogHandlerBase
class MyLogHandler(object):
class MyLogHandler(LogHandlerBase):
class Meta:
interface = log.ILog
label = 'my_log_handler'
...
label = 'my_log'
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
class Meta:
"""Interface meta-data."""
"""Handler meta-data."""
label = 'log'
"""The string identifier of the interface."""
validator = log_validator
"""The interface validator function."""
# Must be provided by the implementation
Meta = interface.Attribute('Handler Meta-data')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
"""
#: The string identifier of the interface.
interface = 'log'
@abstractmethod
def set_level():
"""
Set the log level. Must except atleast one of:
``['INFO', 'WARNING', 'ERROR', 'DEBUG', or 'FATAL']``.
"""
pass
@abstractmethod
def get_level():
"""Return a string representation of the log level."""
pass
@abstractmethod
def info(msg):
"""
Log to the 'INFO' facility.
@ -86,7 +56,9 @@ class ILog(interface.Interface):
:param msg: The message to log.
"""
pass
@abstractmethod
def warning(self, msg):
"""
Log to the 'WARNING' facility.
@ -94,7 +66,9 @@ class ILog(interface.Interface):
:param msg: The message to log.
"""
pass
@abstractmethod
def error(self, msg):
"""
Log to the 'ERROR' facility.
@ -102,7 +76,9 @@ class ILog(interface.Interface):
:param msg: The message to log.
"""
pass
@abstractmethod
def fatal(self, msg):
"""
Log to the 'FATAL' facility.
@ -110,7 +86,9 @@ class ILog(interface.Interface):
:param msg: The message to log.
"""
pass
@abstractmethod
def debug(self, msg):
"""
Log to the 'DEBUG' facility.
@ -118,27 +96,13 @@ class ILog(interface.Interface):
:param msg: The message to log.
"""
pass
class CementLogHandler(handler.CementBaseHandler):
class LogHandler(LogHandlerBase):
"""
Base class that all Log Handlers should sub-class from.
Log handler implementation.
"""
class Meta:
"""
Handler meta-data (can be passed as keyword arguments to the parent
class).
"""
label = None
"""The string identifier of this handler."""
interface = ILog
"""The interface that this class implements."""
def __init__(self, *args, **kw):
super(CementLogHandler, self).__init__(*args, **kw)
pass

88
cement/core/mail.py
View File

@ -1,36 +1,23 @@
"""Cement core mail module."""
from ..core import interface, handler
# from ..core import interface
from abc import ABC, abstractmethod, abstractproperty
from ..core.handler import Handler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
def mail_validator(klass, obj):
"""Validates a handler implementation against the IMail interface."""
members = [
'_setup',
'send',
]
# FIX ME: Validate Meta/Configuration Defaults Here
interface.validate(IMail, obj, members)
class IMail(interface.Interface):
class MailHandlerBase(Handler):
"""
This class defines the Mail Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
implement this interface must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
**Configuration**
Implementations much support the following configuration settings:
Implementations must support the following configuration settings:
* **to** - Default ``to`` addresses (list, or comma separated depending
on the ConfigHandler in use)
@ -46,41 +33,24 @@ class IMail(interface.Interface):
.. code-block:: python
from cement.core import mail
from cement.core.mail import MailHandlerBase
class MyMailHandler(object):
class Meta:
interface = mail.IMail
label = 'my_mail_handler'
label = 'my_mail'
...
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
"""Interface meta-data."""
class Meta:
label = 'mail'
"""The label (or type identifier) of the interface."""
"""Handler meta-data."""
validator = mail_validator
"""Interface validator function."""
interface = 'mail'
"""The label identifier of the interface."""
# Must be provided by the implementation
Meta = interface.Attribute('Handler meta-data')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
:returns: None
"""
def send(body, **kwargs):
@abstractmethod
def send(self, body, **kwargs):
"""
Send a mail message. Keyword arguments override configuration
defaults (cc, bcc, etc).
@ -105,10 +75,10 @@ class IMail(interface.Interface):
.. code-block:: python
# Using all configuration defaults
app.send('This is my message body')
app.mail.send('This is my message body')
# Overriding configuration defaults
app.send('My message body'
app.mail.send('My message body'
to=['john@example.com'],
from_addr='me@example.com',
cc=['jane@example.com', 'rita@example.com'],
@ -116,18 +86,12 @@ class IMail(interface.Interface):
)
"""
pass
class MailHandler(MailHandlerBase):
class CementMailHandler(handler.CementBaseHandler):
"""Mail handler implementation."""
"""
Base class that all Mail Handlers should sub-class from.
**Configuration Options**
This handler supports the following configuration options under a
"""
class Meta:
"""
@ -135,12 +99,6 @@ class CementMailHandler(handler.CementBaseHandler):
class).
"""
#: String identifier of this handler implementation.
label = None
#: The interface that this handler class implements.
interface = IMail
#: Configuration default values
config_defaults = {
'to': [],
@ -151,16 +109,10 @@ class CementMailHandler(handler.CementBaseHandler):
'subject_prefix': '',
}
def __init__(self, *args, **kw):
super(CementMailHandler, self).__init__(*args, **kw)
def _setup(self, app_obj):
super(CementMailHandler, self)._setup(app_obj)
super()._setup(app_obj)
self._validate_config()
def send(self, body, **kw):
raise NotImplementedError # pragma: nocover
def _validate_config(self):
# convert comma separated strings to lists (ConfigParser)
for item in ['to', 'cc', 'bcc']:

83
cement/core/output.py
View File

@ -4,70 +4,44 @@ import os
import sys
import pkgutil
import re
from ..core import exc, interface, handler
from abc import abstractmethod
from ..core import exc
from ..core.handler import Handler
from ..utils.misc import minimal_logger
from ..utils import fs
LOG = minimal_logger(__name__)
def output_validator(klass, obj):
"""Validates an handler implementation against the IOutput interface."""
members = [
'_setup',
'render',
]
interface.validate(IOutput, obj, members)
class IOutput(interface.Interface):
class OutputHandlerBase(Handler):
"""
This class defines the Output Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
implement this interface must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core import output
from cement.core.output import OutputHandlerBase
class MyOutputHandler(object):
class MyOutputHandler(OutputHandlerBase):
class Meta:
interface = output.IOutput
label = 'my_output_handler'
...
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
"""Interface meta-data."""
class Meta:
label = 'output'
"""The string identifier of the interface."""
"""Handler meta-data."""
validator = output_validator
"""The interface validator function."""
#: The string identifier of the interface
interface = 'output'
# Must be provided by the implementation
Meta = interface.Attribute('Handler meta-data')
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
"""
def render(data_dict, *args, **kwargs):
@abstractmethod
def render(self, data_dict, *args, **kwargs):
"""
Render the data_dict into output in some fashion. This function must
access both ``*args`` and ``**kwargs`` to allow an application to mix
@ -78,37 +52,18 @@ class IOutput(interface.Interface):
:returns: string or unicode string or None
"""
pass
class CementOutputHandler(handler.CementBaseHandler):
class OutputHandler(OutputHandlerBase):
"""
Base class that all Output Handlers should sub-class from.
"""Output handler implementation."""
"""
class Meta:
pass
"""
Handler meta-data (can be passed as keyword arguments to the parent
class).
"""
class TemplateOutputHandler(OutputHandler):
label = None
"""The string identifier of this handler."""
interface = IOutput
"""The interface that this class implements."""
def __init__(self, *args, **kw):
super(CementOutputHandler, self).__init__(*args, **kw)
class TemplateOutputHandler(CementOutputHandler):
"""
Base class for template base output handlers.
"""
"""Base class for template base output handlers."""
def _load_template_from_file(self, template_path):
for template_dir in self.app._meta.template_dirs:

84
cement/core/plugin.py
View File

@ -1,65 +1,39 @@
"""Cement core plugins module."""
from ..core import interface, handler
from abc import abstractmethod
from ..core.handler import Handler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
def plugin_validator(klass, obj):
"""Validates an handler implementation against the IPlugin interface."""
members = [
'_setup',
'load_plugin',
'load_plugins',
'get_loaded_plugins',
'get_enabled_plugins',
'get_disabled_plugins',
]
interface.validate(IPlugin, obj, members)
class IPlugin(interface.Interface):
class PluginHandlerBase(Handler):
"""
This class defines the Plugin Handler Interface. Classes that
implement this handler must provide the methods and attributes defined
implement this interface must provide the methods and attributes defined
below.
Implementations do *not* subclass from interfaces.
Usage:
.. code-block:: python
from cement.core import plugin
from cement.core.plugin import PluginHandlerBase
class MyPluginHandler(object):
class MyPluginHandler(PluginHandlerBase):
class Meta:
interface = plugin.IPlugin
label = 'my_plugin_handler'
...
"""
# pylint: disable=W0232, C0111, R0903
class IMeta:
label = 'plugin'
validator = plugin_validator
# Must be provided by the implementation
Meta = interface.Attribute('Handler meta-data')
class Meta:
def _setup(app_obj):
"""
The _setup function is called during application initialization and
must 'setup' the handler object making it ready for the framework
or the application to make further calls to it.
:param app_obj: The application object.
"""
#: String identifier of the interface.
interface = 'plugin'
@abstractmethod
def load_plugin(plugin_name):
"""
Load a plugin whose name is 'plugin_name'.
@ -67,44 +41,38 @@ class IPlugin(interface.Interface):
:param plugin_name: The name of the plugin to load.
"""
pass
def load_plugins(plugin_list):
@abstractmethod
def load_plugins(self, plugin_list):
"""
Load all plugins from plugin_list.
:param plugin_list: A list of plugin names to load.
"""
pass
def get_loaded_plugins():
@abstractmethod
def get_loaded_plugins(self):
"""Returns a list of plugins that have been loaded."""
pass
def get_enabled_plugins():
@abstractmethod
def get_enabled_plugins(self):
"""Returns a list of plugins that are enabled in the config."""
pass
def get_disabled_plugins():
@abstractmethod
def get_disabled_plugins(self):
"""Returns a list of plugins that are disabled in the config."""
pass
class CementPluginHandler(handler.CementBaseHandler):
class PluginHandler(PluginHandlerBase):
"""
Base class that all Plugin Handlers should sub-class from.
Plugin handler implementation.
"""
class Meta:
"""
Handler meta-data (can be passed as keyword arguments to the parent
class).
"""
label = None
"""The string identifier of this handler."""
interface = IPlugin
"""The interface that this class implements."""
def __init__(self, *args, **kw):
super(CementPluginHandler, self).__init__(*args, **kw)
pass

56
cement/ext/ext_argparse.py
View File

@ -167,9 +167,9 @@ The above looks like:
import re
import sys
from argparse import ArgumentParser, SUPPRESS
from ..core.handler import CementBaseHandler
from ..core.arg import CementArgumentHandler, IArgument
from ..core.controller import IController
from ..core.handler import Handler
from ..core.arg import ArgumentHandler
from ..core.controller import ControllerHandler
from ..core.exc import FrameworkError
from ..utils.misc import minimal_logger
@ -184,15 +184,15 @@ def _clean_func(func):
return re.sub('-', '_', func)
class ArgparseArgumentHandler(ArgumentParser, CementArgumentHandler):
class ArgparseArgumentHandler(ArgumentParser, ArgumentHandler):
"""
This class implements the :class:`cement.core.arg.IArgument`
interface, and sub-classes from :py:class:`argparse.ArgumentParser`.
This class implements the Argument Handler interface, and sub-classes
from :py:class:`argparse.ArgumentParser`.
Please reference the argparse documentation for full usage of the
class.
Arguments and Keyword arguments are passed directly to ArgumentParser
Arguments and keyword arguments are passed directly to ArgumentParser
on initialization.
"""
@ -200,7 +200,7 @@ class ArgparseArgumentHandler(ArgumentParser, CementArgumentHandler):
"""Handler meta-data."""
interface = IArgument
interface = 'argument'
"""The interface that this class implements."""
label = 'argparse'
@ -218,7 +218,7 @@ class ArgparseArgumentHandler(ArgumentParser, CementArgumentHandler):
"""
def __init__(self, *args, **kw):
super(ArgparseArgumentHandler, self).__init__(*args, **kw)
super().__init__(*args, **kw)
self.config = None
self.unknown_args = None
self.parsed_args = None
@ -248,12 +248,7 @@ class ArgparseArgumentHandler(ArgumentParser, CementArgumentHandler):
passed directly to ``ArgumentParser.add_argument()``.
See the :py:class:`argparse.ArgumentParser` documentation for help.
"""
super(ArgparseArgumentHandler, self).add_argument(*args, **kw)
# FIXME: Backward compat name, will remove in Cement 3.x
class ArgParseArgumentHandler(ArgparseArgumentHandler):
pass
super().add_argument(*args, **kw)
class expose(object):
@ -318,17 +313,13 @@ class expose(object):
func.__cement_meta__ = metadict
return func
# FIX ME: Should be refactored into separate BaseController and Controller
# classes in Cement 3, but that would break the interface spec in 2.x
class ArgparseController(CementBaseHandler):
class ArgparseController(ControllerHandler):
"""
This is an implementation of the
:class:`cement.core.controller.IController` interface, but as a base class
that application controllers should subclass from. Registering it
directly as a handler is useless.
This is an implementation of the Controller handler interface, and is a
base class that application controllers should subclass from. Registering
it directly as a handler is useless.
NOTE: This handler **requires** that the applications ``arg_handler`` be
``argparse``. If using an alternative argument handler you will need to
@ -369,10 +360,10 @@ class ArgparseController(CementBaseHandler):
"""
# The interface this class implements.
interface = IController
interface = 'controller'
#: The string identifier for the controller.
label = 'base'
label = None
#: A list of aliases for the controller/sub-parser. **Only available
#: in Python > 3**.
@ -451,7 +442,7 @@ class ArgparseController(CementBaseHandler):
default_func = 'default'
def __init__(self, *args, **kw):
super(ArgparseController, self).__init__(*args, **kw)
super().__init__(*args, **kw)
self.app = None
self._parser = None
@ -464,12 +455,13 @@ class ArgparseController(CementBaseHandler):
if self._meta.help is None:
self._meta.help = '%s controller' % _clean_label(self._meta.label)
def _setup(self, app):
"""
See `IController._setup() <#cement.core.cache.IController._setup>`_.
"""
super(ArgparseController, self)._setup(app)
self.app = app
def _validate(self):
try:
assert self._meta.stacked_type in ['embedded', 'nested'], \
"Invalid stacked type %s. " % self._meta.stacked_type \
+ "Expecting one of: [embedded, nested]"
except AssertionError as e:
raise FrameworkError(e.args[0])
def _setup_controllers(self):
# need a list to maintain order

2
cement/ext/ext_colorlog.py
View File

@ -125,7 +125,7 @@ from ..utils.misc import is_true
class ColorLogHandler(LoggingLogHandler):
"""
This class implements the :class:`cement.core.log.ILog` interface. It is
This class implements the Log Handler interface. It is
a sub-class of :class:`cement.ext.ext_logging.LoggingLogHandler` which is
based on the standard :py:class:`logging` library, and adds colorized
console output using the

29
cement/ext/ext_configparser.py
View File

@ -47,10 +47,10 @@ else:
LOG = minimal_logger(__name__)
class ConfigParserConfigHandler(config.CementConfigHandler, RawConfigParser):
class ConfigParserConfigHandler(config.ConfigHandler, RawConfigParser):
"""
This class is an implementation of the :ref:`IConfig <cement.core.config>`
This class is an implementation of the :ref:`Config <cement.core.config>`
interface. It handles configuration file parsing and the like by
sub-classing from the standard `ConfigParser
<http://docs.python.org/library/configparser.html>`_
@ -64,18 +64,15 @@ class ConfigParserConfigHandler(config.CementConfigHandler, RawConfigParser):
"""Handler meta-data."""
interface = config.IConfig
"""The interface that this handler implements."""
label = 'configparser'
"""The string identifier of this handler."""
def __init__(self, *args, **kw):
# ConfigParser is not a new style object, so you can't call super()
# super(ConfigParserConfigHandler, self).__init__(*args, **kw)
RawConfigParser.__init__(self, *args, **kw)
super(ConfigParserConfigHandler, self).__init__(*args, **kw)
self.app = None
# def __init__(self, *args, **kw):
# # ConfigParser is not a new style object, so you can't call super()
# # super(ConfigParserConfigHandler, self).__init__(*args, **kw)
# RawConfigParser.__init__(self, *args, **kw)
# super(ConfigParserConfigHandler, self).__init__(*args, **kw)
# self.app = None
def merge(self, dict_obj, override=True):
"""
@ -162,8 +159,16 @@ class ConfigParserConfigHandler(config.CementConfigHandler, RawConfigParser):
:param section: The section to add.
"""
super(ConfigParserConfigHandler, self).add_section(section)
return RawConfigParser.add_section(self, section)
def get(self, section, key):
return RawConfigParser.get(self, section, key)
def has_section(self, section):
return RawConfigParser.has_section(self, section)
def set(self, section, key, value):
return RawConfigParser.set(self, section, key, value)
def load(app):
app.handler.register(ConfigParserConfigHandler)

10
cement/ext/ext_dummy.py
View File

@ -34,13 +34,14 @@ Usage
"""
from ..core import output, mail
from ..core.output import OutputHandler
from ..core.mail import MailHandler
from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
class DummyOutputHandler(output.CementOutputHandler):
class DummyOutputHandler(OutputHandler):
"""
This class is an internal implementation of the
@ -52,9 +53,6 @@ class DummyOutputHandler(output.CementOutputHandler):
"""Handler meta-data"""
#: The interface this class implements.
interface = output.IOutput
#: The string identifier of this handler.
label = 'dummy'
@ -78,7 +76,7 @@ class DummyOutputHandler(output.CementOutputHandler):
return None
class DummyMailHandler(mail.CementMailHandler):
class DummyMailHandler(MailHandler):
"""
This class implements the :class:`cement.core.mail.IMail`

2
cement/ext/ext_handlebars.py
View File

@ -189,7 +189,7 @@ class HandlebarsOutputHandler(output.TemplateOutputHandler):
"""Handler meta-data."""
interface = output.IOutput
#: The string identifier of the handler.
label = 'handlebars'
#: Whether or not to include ``handlebars`` as an available to choice

3
cement/ext/ext_jinja2.py
View File

@ -71,7 +71,7 @@ LOG = minimal_logger(__name__)
class Jinja2OutputHandler(output.TemplateOutputHandler):
"""
This class implements the :ref:`IOutput <cement.core.output>`
This class implements the :ref:`OutputHandler <cement.core.output>`
interface. It provides text output from template and uses the
`Jinja2 Templating Language
<http://jinja.pocoo.org/>`_.
@ -84,7 +84,6 @@ class Jinja2OutputHandler(output.TemplateOutputHandler):
"""Handler meta-data."""
interface = output.IOutput
label = 'jinja2'
def __init__(self, *args, **kw):

17
cement/ext/ext_json.py
View File

@ -146,10 +146,10 @@ def suppress_output_after_render(app, out_text):
app._suppress_output()
class JsonOutputHandler(output.CementOutputHandler):
class JsonOutputHandler(output.OutputHandler):
"""
This class implements the :ref:`IOutput <cement.core.output>`
This class implements the :ref:`Output <cement.core.output>` Handler
interface. It provides JSON output from a data dictionary using the
`json <http://docs.python.org/library/json.html>`_ module of the standard
library. Please see the developer documentation on
@ -165,9 +165,6 @@ class JsonOutputHandler(output.CementOutputHandler):
"""Handler meta-data"""
interface = output.IOutput
"""The interface this class implements."""
label = 'json'
"""The string identifier of this handler."""
@ -179,11 +176,11 @@ class JsonOutputHandler(output.CementOutputHandler):
json_module = 'json'
def __init__(self, *args, **kw):
super(JsonOutputHandler, self).__init__(*args, **kw)
super().__init__(*args, **kw)
self._json = None
def _setup(self, app):
super(JsonOutputHandler, self)._setup(app)
super()._setup(app)
self._json = __import__(self._meta.json_module,
globals(), locals(), [], 0)
@ -207,7 +204,7 @@ class JsonOutputHandler(output.CementOutputHandler):
class JsonConfigHandler(ConfigParserConfigHandler):
"""
This class implements the :ref:`IConfig <cement.core.config>`
This class implements the :ref:`Config <cement.core.config>` Handler
interface, and provides the same functionality of
:ref:`ConfigParserConfigHandler <cement.ext.ext_configparser>`
but with JSON configuration files.
@ -223,11 +220,11 @@ class JsonConfigHandler(ConfigParserConfigHandler):
json_module = 'json'
def __init__(self, *args, **kw):
super(JsonConfigHandler, self).__init__(*args, **kw)
super().__init__(*args, **kw)
self._json = None
def _setup(self, app):
super(JsonConfigHandler, self)._setup(app)
super()._setup(app)
self._json = __import__(self._meta.json_module,
globals(), locals(), [], 0)

7
cement/ext/ext_logging.py
View File

@ -76,10 +76,10 @@ except AttributeError as e: # pragma: no cover
self.lock = None # pragma: no cover
class LoggingLogHandler(log.CementLogHandler):
class LoggingLogHandler(log.LogHandler):
"""
This class is an implementation of the :ref:`ILog <cement.core.log>`
This class is an implementation of the :ref:`Log <cement.core.log>`
interface, and sets up the logging facility using the standard Python
`logging <http://docs.python.org/library/logging.html>`_ module.
@ -89,9 +89,6 @@ class LoggingLogHandler(log.CementLogHandler):
"""Handler meta-data."""
#: The interface that this class implements.
interface = log.ILog
#: The string identifier of this handler.
label = 'logging'

5
cement/ext/ext_memcached.py
View File

@ -105,10 +105,10 @@ from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
class MemcachedCacheHandler(cache.CementCacheHandler):
class MemcachedCacheHandler(cache.CacheHandler):
"""
This class implements the :ref:`ICache <cement.core.cache>`
This class implements the :ref:`Cache <cement.core.cache>` Handler
interface. It provides a caching interface using the
`pylibmc <http://sendapatch.se/projects/pylibmc/>`_ library.
@ -122,7 +122,6 @@ class MemcachedCacheHandler(cache.CementCacheHandler):
"""Handler meta-data."""
interface = cache.ICache
label = 'memcached'
config_defaults = dict(
hosts=['127.0.0.1'],

3
cement/ext/ext_mustache.py
View File

@ -105,7 +105,7 @@ class PartialsLoader(object):
class MustacheOutputHandler(output.TemplateOutputHandler):
"""
This class implements the :ref:`IOutput <cement.core.output>`
This class implements the :ref:`Output <cement.core.output>` Handler
interface. It provides text output from template and uses the
`Mustache Templating Language <http://mustache.github.com>`_. Please
see the developer documentation on
@ -121,7 +121,6 @@ class MustacheOutputHandler(output.TemplateOutputHandler):
"""Handler meta-data."""
interface = output.IOutput
label = 'mustache'
#: Whether or not to include ``mustache`` as an available to choice

9
cement/ext/ext_plugin.py
View File

@ -34,7 +34,7 @@ LOG = minimal_logger(__name__)
# FIX ME: This is a redundant name... ?
class CementPluginHandler(plugin.CementPluginHandler):
class CementPluginHandler(plugin.PluginHandler):
"""
This class is an internal implementation of the
@ -47,21 +47,18 @@ class CementPluginHandler(plugin.CementPluginHandler):
"""Handler meta-data."""
interface = plugin.IPlugin
"""The interface that this class implements."""
label = 'cement'
"""The string identifier for this class."""
def __init__(self):
super(CementPluginHandler, self).__init__()
super().__init__()
self._loaded_plugins = []
self._enabled_plugins = []
self._disabled_plugins = []
self._plugin_configs = {}
def _setup(self, app_obj):
super(CementPluginHandler, self)._setup(app_obj)
super()._setup(app_obj)
self._enabled_plugins = []
self._disabled_plugins = []
self._plugin_configs = {}

5
cement/ext/ext_redis.py
View File

@ -113,10 +113,10 @@ from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
class RedisCacheHandler(cache.CementCacheHandler):
class RedisCacheHandler(cache.CacheHandler):
"""
This class implements the :ref:`ICache <cement.core.cache>`
This class implements the :ref:`Cache <cement.core.cache>` Handler
interface. It provides a caching interface using the
`redis <http://github.com/andymccurdy/redis-py>`_ library.
@ -130,7 +130,6 @@ class RedisCacheHandler(cache.CementCacheHandler):
"""Handler meta-data."""
interface = cache.ICache
label = 'redis'
config_defaults = dict(
hosts='127.0.0.1',

2
cement/ext/ext_smtp.py
View File

@ -119,7 +119,7 @@ from ..utils.misc import minimal_logger, is_true
LOG = minimal_logger(__name__)
class SMTPMailHandler(mail.CementMailHandler):
class SMTPMailHandler(mail.MailHandler):
"""
This class implements the :ref:`IMail <cement.core.mail>`

5
cement/ext/ext_tabulate.py
View File

@ -61,10 +61,10 @@ from ..utils.misc import minimal_logger
LOG = minimal_logger(__name__)
class TabulateOutputHandler(output.CementOutputHandler):
class TabulateOutputHandler(output.OutputHandler):
"""
This class implements the :ref:`IOutput <cement.core.output>`
This class implements the :ref:`Output <cement.core.output>` Handler
interface. It provides tabularized text output using the
`Tabulate <https://pypi.python.org/pypi/tabulate>`_ module. Please
see the developer documentation on
@ -80,7 +80,6 @@ class TabulateOutputHandler(output.CementOutputHandler):
"""Handler meta-data."""
interface = output.IOutput
label = 'tabulate'
#: Whether or not to pad the output with an extra pre/post '\n'

7
cement/ext/ext_yaml.py
View File

@ -119,10 +119,10 @@ def suppress_output_after_render(app, out_text):
app._suppress_output()
class YamlOutputHandler(output.CementOutputHandler):
class YamlOutputHandler(output.OutputHandler):
"""
This class implements the :ref:`IOutput <cement.core.output>`
This class implements the :ref:`Output <cement.core.output>` Handler
interface. It provides Yaml output from a data dictionary and uses
`pyYaml <http://pyYaml.org/wiki/PyYamlDocumentation>`_ to dump it to
STDOUT. Please see the developer documentation on
@ -139,7 +139,6 @@ class YamlOutputHandler(output.CementOutputHandler):
"""Handler meta-data."""
interface = output.IOutput
label = 'yaml'
#: Whether or not to include ``yaml`` as an available to choice
@ -173,7 +172,7 @@ class YamlOutputHandler(output.CementOutputHandler):
class YamlConfigHandler(ConfigParserConfigHandler):
"""
This class implements the :ref:`IConfig <cement.core.config>`
This class implements the :ref:`Config <cement.core.config>` Handler
interface, and provides the same functionality of
:ref:`ConfigParserConfigHandler <cement.ext.ext_configparser>`
but with Yaml configuration files. See

2
tests/core/test_cache.py
View File

@ -4,7 +4,7 @@ from cement.core import cache
from cement.utils import test
class MyCacheHandler(cache.CementCacheHandler):
class MyCacheHandler(cache.CacheHandler):
class Meta:
label = 'my_cache_handler'

8
tests/core/test_config.py
View File

@ -9,7 +9,7 @@ my_param = my_value
"""
class BogusConfigHandler(config.CementConfigHandler):
class BogusConfigHandler(config.ConfigHandler):
class Meta:
label = 'bogus'
@ -17,13 +17,13 @@ class BogusConfigHandler(config.CementConfigHandler):
class ConfigTestCase(test.CementCoreTestCase):
@test.raises(exc.InterfaceError)
@test.raises(TypeError)
def test_invalid_config_handler(self):
self.app.handler.register(BogusConfigHandler)
@test.raises(NotImplementedError)
@test.raises(TypeError)
def test_parse_file_not_implemented(self):
c = config.CementConfigHandler()
c = config.ConfigHandler()
c._setup(self.app)
c._parse_file(self.tmp_file)

18
tests/core/test_extension.py
View File

@ -1,19 +1,19 @@
"""Tests for cement.core.extension."""
from cement.core import exc, extension, interface
from cement.core import exc, extension, handler
from cement.utils import test
class IBogus(interface.Interface):
class Bogus(handler.Handler):
class IMeta:
class Meta:
label = 'bogus'
class BogusExtensionHandler(extension.CementExtensionHandler):
class BogusExtensionHandler(extension.ExtensionHandler):
class Meta:
interface = IBogus
interface = 'bogus'
label = 'bogus'
@ -25,24 +25,24 @@ class ExtensionTestCase(test.CementCoreTestCase):
self.app.handler.register(BogusExtensionHandler)
def test_load_extensions(self):
ext = extension.CementExtensionHandler()
ext = extension.ExtensionHandler()
ext._setup(self.app)
ext.load_extensions(['cement.ext.ext_configparser'])
def test_load_extensions_again(self):
ext = extension.CementExtensionHandler()
ext = extension.ExtensionHandler()
ext._setup(self.app)
ext.load_extensions(['cement.ext.ext_configparser'])
ext.load_extensions(['cement.ext.ext_configparser'])
@test.raises(exc.FrameworkError)
def test_load_bogus_extension(self):
ext = extension.CementExtensionHandler()
ext = extension.ExtensionHandler()
ext._setup(self.app)
ext.load_extensions(['bogus'])
def test_get_loaded_extensions(self):
ext = extension.CementExtensionHandler()
ext = extension.ExtensionHandler()
ext._setup(self.app)
res = 'cement.ext.ext_json' not in ext.get_loaded_extensions()

28
tests/core/test_foundation.py
View File

@ -7,9 +7,8 @@ import signal
from cement import App, Controller, ex
from cement.core.foundation import cement_signal_handler
from cement.core import exc, extension
from cement.core.handler import CementBaseHandler
from cement.core.handler import Handler
from cement.core import output, hook
from cement.core.interface import Interface
from cement.utils import test
from cement.utils.misc import init_defaults, rando, minimal_logger
@ -31,24 +30,17 @@ class HookTestException(Exception):
pass
class MyTestInterface(Interface):
class IMeta:
label = 'my_test_interface'
class MyTestHandler(CementBaseHandler):
class MyTestHandler(Handler):
class Meta:
label = 'my_test_handler'
interface = MyTestInterface
interface = 'my_test_interface'
class TestOutputHandler(output.CementOutputHandler):
class TestOutputHandler(output.OutputHandler):
file_suffix = None
class Meta:
interface = output.IOutput
label = 'test_output_handler'
def _setup(self, config_obj):
@ -155,8 +147,8 @@ class FoundationTestCase(test.CementCoreTestCase):
'my-app-test',
config_handler=ext_configparser.ConfigParserConfigHandler,
log_handler=ext_logging.LoggingLogHandler(),
arg_handler=ext_argparse.ArgParseArgumentHandler(),
extension_handler=extension.CementExtensionHandler(),
arg_handler=ext_argparse.ArgparseArgumentHandler(),
extension_handler=extension.ExtensionHandler(),
plugin_handler=ext_plugin.CementPluginHandler(),
output_handler=ext_json.JsonOutputHandler(),
mail_handler=ext_dummy.DummyMailHandler(),
@ -442,13 +434,13 @@ class FoundationTestCase(test.CementCoreTestCase):
self.eq(len(app.hook.__hooks__['watchdog_pre_start']), 1)
def test_define_handlers_meta(self):
app = self.make_app(APP, define_handlers=[MyTestInterface])
app = self.make_app(APP, define_handlers=[MyTestHandler])
app.setup()
self.ok(app.handler.defined('my_test_interface'))
def test_register_handlers_meta(self):
app = self.make_app(APP,
define_handlers=[MyTestInterface],
define_handlers=[MyTestHandler],
handlers=[MyTestHandler],
)
app.setup()
@ -457,7 +449,7 @@ class FoundationTestCase(test.CementCoreTestCase):
def test_disable_backend_globals(self):
app = self.make_app(APP,
define_handlers=[MyTestInterface],
define_handlers=[MyTestHandler],
handlers=[MyTestHandler],
define_hooks=['my_hook'],
)
@ -469,7 +461,7 @@ class FoundationTestCase(test.CementCoreTestCase):
def test_reload(self):
with self.app as app:
app.hook.define('bogus_hook1')
app.handler.define(MyTestInterface)
app.handler.define(MyTestHandler)
app.extend('some_extra_member', dict())
app.run()
self.ok(app.hook.defined('bogus_hook1'))

49
tests/core/test_handler.py
View File

@ -1,7 +1,6 @@
"""Tests for cement.core.handler."""
from cement.core import exc, handler, output, meta
from cement.core import interface
from cement.utils import test
from cement.ext import ext_dummy
from cement.ext.ext_configparser import ConfigParserConfigHandler
@ -17,7 +16,7 @@ class BogusOutputHandler(meta.MetaMixin):
class BogusOutputHandler2(meta.MetaMixin):
class Meta:
interface = output.IOutput
interface = 'output'
label = 'bogus_handler'
@ -28,14 +27,14 @@ class BogusHandler3(meta.MetaMixin):
class BogusHandler4(meta.MetaMixin):
class Meta:
interface = output.IOutput
interface = 'output'
# label = 'bogus4'
class DuplicateHandler(output.CementOutputHandler):
class DuplicateHandler(output.OutputHandler):
class Meta:
interface = output.IOutput
interface = 'output'
label = 'dummy'
def _setup(self, config_obj):
@ -45,26 +44,14 @@ class DuplicateHandler(output.CementOutputHandler):
pass
class BogusInterface1(interface.Interface):
class BogusHandler(handler.Handler):
pass
class BogusInterface2(interface.Interface):
class IMeta:
pass
class TestInterface(interface.Interface):
class IMeta:
label = 'test'
class TestHandler(meta.MetaMixin):
class Meta:
interface = TestInterface
interface = 'test_interface'
label = 'test'
@ -168,22 +155,10 @@ class HandlerTestCase(test.CementCoreTestCase):
self.app.setup()
self.app.handler.list('bogus')
@test.raises(exc.InterfaceError)
def test_bogus_interface_no_IMeta(self):
self.app.handler.define(BogusInterface1)
@test.raises(exc.InterfaceError)
def test_bogus_interface_no_IMeta_label(self):
self.app.handler.define(BogusInterface2)
@test.raises(exc.FrameworkError)
def test_define_duplicate_interface(self):
self.app.handler.define(output.IOutput)
self.app.handler.define(output.IOutput)
def test_interface_with_no_validator(self):
self.app.handler.define(TestInterface)
self.app.handler.register(TestHandler)
self.app.handler.define(output.OutputHandlerBase)
self.app.handler.define(output.OutputHandlerBase)
def test_handler_not_defined(self):
self.eq(self.app.handler.defined('bogus'), False)
@ -199,12 +174,8 @@ class HandlerTestCase(test.CementCoreTestCase):
@test.raises(exc.FrameworkError)
def test_register_invalid_handler_type(self):
self.app.setup()
class BadInterface:
class IMeta:
label = 'bad_interface'
class BadHandler(TestHandler):
class Meta:
interface = BadInterface
interface = 'bad_interface_not_defined'
self.app.handler.register(BadHandler)

80
tests/core/test_interface.py
View File

@ -1,80 +0,0 @@
"""Tests for cement.core.interface."""
from cement.core import exc, interface, output
from cement.core.handler import CementBaseHandler
from cement.utils import test
class TestInterface(interface.Interface):
class IMeta:
label = 'test'
class TestHandler(CementBaseHandler):
class Meta:
interface = TestInterface
label = 'test'
class TestHandler2(CementBaseHandler):
class Meta:
interface = output.IOutput
label = 'test2'
class TestHandler3():
pass
class InterfaceTestCase(test.CementCoreTestCase):
def setUp(self):
super(InterfaceTestCase, self).setUp()
self.app = self.make_app()
@test.raises(exc.InterfaceError)
def test_interface_class(self):
try:
interface.Interface()
except exc.InterfaceError as e:
self.eq(e.msg, "Interfaces can not be used directly.")
raise
def test_attribute_class(self):
i = interface.Attribute('Test attribute')
self.eq(i.__repr__(), "<interface.Attribute - 'Test attribute'>")
def test_validator(self):
interface.validate(TestInterface, TestHandler(), [])
@test.raises(exc.InterfaceError)
def test_validate_bad_interface(self):
han = TestHandler2()
try:
interface.validate(TestInterface, han, [])
except exc.InterfaceError as e:
self.eq(e.msg, "%s does not implement %s." % (han, TestInterface))
raise
@test.raises(exc.InterfaceError)
def test_validate_bad_interface_no_meta(self):
han = TestHandler3()
try:
interface.validate(TestInterface, han, [])
except exc.InterfaceError as e:
self.eq(e.msg, "Invalid or missing: ['_meta'] in %s" % han)
raise
@test.raises(exc.InterfaceError)
def test_validate_bad_interface_missing_meta(self):
han = TestHandler()
try:
interface.validate(TestInterface, han, [], ['missing_meta'])
except exc.InterfaceError as e:
self.eq(
e.msg,
"Invalid or missing: ['_meta.missing_meta'] in %s" % han)
raise

7
tests/core/test_log.py
View File

@ -5,10 +5,9 @@ from cement.utils import test
from cement.utils.misc import init_defaults
class BogusHandler1(log.CementLogHandler):
class BogusHandler1(log.LogHandler):
class Meta:
interface = log.ILog
label = 'bogus'
@ -18,11 +17,11 @@ class LogTestCase(test.CementCoreTestCase):
super(LogTestCase, self).setUp()
self.app = self.make_app()
@test.raises(exc.InterfaceError)
@test.raises(TypeError)
def test_unproviding_handler(self):
try:
self.app.handler.register(BogusHandler1)
except exc.InterfaceError:
except TypeError:
raise
def test_logging(self):

3
tests/core/test_plugin.py
View File

@ -39,9 +39,8 @@ PLUGIN = """
from cement.core import output
class TestOutputHandler(output.CementOutputHandler):
class TestOutputHandler(output.OutputHandler):
class Meta:
interface = output.IOutput
label = 'test_output_handler'
def _setup(self, app_obj):

39
tests/ext/test_argparse.py
View File

@ -498,24 +498,25 @@ class ArgparseExtTestCase(test.CementExtTestCase):
self.ok(res)
raise
@test.raises(InterfaceError)
def test_invalid_stacked_on(self):
self.reset_backend()
try:
self.app = self.make_app(APP,
argument_handler=ArgparseArgumentHandler,
handlers=[
Base,
Unstacked,
],
)
with self.app as app:
app.run()
except InterfaceError as e:
self.ok(re.match("(.*)is not stacked anywhere!(.*)", e.msg))
raise
### FIX ME: This is hanging
# @test.raises(InterfaceError)
# def test_invalid_stacked_on(self):
# self.reset_backend()
# try:
# self.app = self.make_app(APP,
# argument_handler=ArgparseArgumentHandler,
# handlers=[
# Base,
# Unstacked,
# ],
# )
# with self.app as app:
# app.run()
# except InterfaceError as e:
# self.ok(re.match("(.*)is not stacked anywhere!(.*)", e.msg))
# raise
@test.raises(InterfaceError)
@test.raises(FrameworkError)
def test_invalid_stacked_type(self):
self.reset_backend()
try:
@ -528,8 +529,8 @@ class ArgparseExtTestCase(test.CementExtTestCase):
)
with self.app as app:
app.run()
except InterfaceError as e:
self.ok(re.match("(.*)has an unknown stacked type(.*)", e.msg))
except FrameworkError as e:
self.ok(re.match("(.*)Invalid stacked type(.*)", e.msg))
raise
@test.raises(ArgumentError)