Merge branch 'newlodel' of git.labocleo.org:lodel2 into newlodel

lodel/leapi/query.py

@@ -7,92 +7,121 @@ from .leobject import LeObject, LeApiErrors, LeApiDataCheckError
 class LeQueryError(Exception):
     pass
 
-
 class LeQuery(object):
 
     ## @brief The datasource object used for this query
-    _datasource = None
+    datasource = None
 
     ## @brief The available operators used in query definitions
-    _query_operators = ['=', '<=', '>=', '!=', '<', '>', ' in ', ' not in ', ' like ', ' not like ']
+    query_operators = ['=', '<=', '>=', '!=', '<', '>', ' in ', ' not in ', ' like ', ' not like ']
 
+    ## @brief Constructor
+    # @param target_class EmClass : class of the object to query about
     def __init__(self, target_class):
         if not issubclass(target_class, LeObject):
             raise TypeError("target class has to be a child class of LeObject")
-        self._target_class = target_class
+        self.target_class = target_class
 
 
+## @brief Class representing an Insert query
 class LeInsertQuery(LeQuery):
-    action = 'insert'
-
-    def __init__(self, target_class, datas, classname=None):
-        targeted_class = target_class if classname is None else LeObject.name2class(classname)
-        if not targeted_class:
-            raise LeQueryError('Error when inserting', {'error': ValueError("The class '%s' was not found" % classname)})
 
-        super().__init__(targeted_class)
+    ## @brief Constructor
+    # @param target_class EmClass: class corresponding to the inserted object
+    # @param datas dict : datas to insert
+    def __init__(self, target_class, datas):
+        super().__init__(target_class)
         self.datas = datas
 
-    # @todo Reactivate the LodelHooks call when this class is implemented
+    ## @brief executes the insert query
+    # @return bool
+    # @TODO reactivate the LodelHooks call when this class is implemented
     def execute(self):
-        datas = self.datas  # TODO : replace with LodelHooks.call_hook('leapi_insert_pre', self._target_class, self.datas)
+        datas = self.datas  # LodelHooks.call_hook('leapi_insert_pre', self.target_class, self.datas)
         ret = self.__insert(**datas)
-        # ret = LodelHook.call_hook('leapi_insert_post', self._target_class, ret)
+        # ret = LodelHook.call_hook('leapi_insert_post', self.target_class, ret)
         return ret
 
-    def __insert(self):
-        insert_datas = self._target_class.prepare_datas(self.datas, complete=True, allow_internal=True)
-        return self._datasource.insert(self._target_class, **insert_datas)
+    ## @brief calls the datasource to perform the insert command
+    # @param datas dict : formatted datas corresponding to the insert
+    # @return str : the uid of the inserted object
+    def __insert(self, **datas):
+        insert_datas = self.target_class.prepare_datas(datas, complete=True, allow_internal=True)
+        res = self.datasource.insert(self.target_class, **insert_datas)
+        return res
 
 
+## @brief Class representing an Abstract Filtered Query
 class LeFilteredQuery(LeQuery):
 
+    ## @brief Constructor
+    # @param target_class EmClass : Object of the query
     def __init__(self, target_class):
         super().__init__(target_class)
 
+    ## @brief Validates the query filters
+    # @param query_filters list
+    # @return bool
+    # @raise LeQueryError if one of the filter is not valid
     @classmethod
     def validate_query_filters(cls, query_filters):
         for query_filter in query_filters:
-            if query_filter[1] not in cls._query_operators:
+            if query_filter[1] not in cls.query_operators:
                 raise LeQueryError("The operator %s is not valid." % query_filter[1])
         return True
 
+    ## @brief Checks if a field is relational
+    # @param field str : Name of the field
+    # @return bool
     @classmethod
     def is_relational_field(cls, field):
         return field.startswith('superior.') or field.startswith('subordinate.')
 
+
+## @brief Class representing a Get Query
 class LeGetQuery(LeFilteredQuery):
 
-    def __init__(self, target_class, target_uid, query_filters, field_list=None, order=None, group=None, limit=None, offset=0, instanciate=True):
+    ## @brief Constructor
+    # @param target_class EmClass : main class
+    # @param query_filters
+    # @param field_list list
+    # @param order list : list of tuples corresponding to the fields used to sort the results
+    # @param group list : list of tuples corresponding to the fields used to group the results
+    # @param limit int : Maximum number of results to get
+    # @param offset int
+    # @param instanciate bool : if True, objects will be returned instead of dictionaries
+    def __init__(self, target_class, query_filters, field_list=None, order=None, group=None, limit=None, offset=0, instanciate=True):
         super().__init__(target_class)
         self.query_filters = query_filters
         self.default_field_list = []
-        self.field_list = field_list if field_list is not None else self._target_class.fieldnames()
+        self.field_list = field_list if field_list is not None else self.target_class.fieldnames()
         self.order = order
         self.group = group
         self.limit = limit
         self.offset = offset
         self.instanciate = instanciate
-        self.target_object = None  # TODO get an instance of the target_class using a unique id
 
+    ## @brief executes the query
+    # @return list
+    # @TODO activate LodelHook calls
     def execute(self):
-        datas = self.datas  # TODO : replace with LodelHook.call_hook('leapi_get_pre', self.target_object, self.datas)
+        datas = self.datas  # LodelHook.call_hook('leapi_get_pre', self.target_object, self.datas)
         ret = self.__get(**datas)
         # ret = LodelHook.call_hook('leapi_get_post', self.target_object, ret)
         return ret
 
-    def __get(self, **kwargs):
-        field_list = self.__prepare_field_list(self.field_list)  #TODO implement the prepare_field_list method
+    def __get(self, **datas):
+        field_list = self.__prepare_field_list(self.field_list)
 
         query_filters, relational_filters = self.__prepare_filters()
 
-        # Preparing order
+        # Preparing the "order" parameters
         if self.order:
             order = self.__prepare_order()
             if isinstance(order, Exception):
-                raise order  # can be buffered and raised later, but _prepare_filters raise when fails
+                raise order  # can be buffered and raised later, but __prepare_filters raise when fails
 
-        # Preparing group
+        # Preparing the "group" parameters
         if self.group:
             group = self.__prepare_order()
             if isinstance(group, Exception):
@@ -108,12 +137,15 @@ class LeGetQuery(LeFilteredQuery):
         results = self._datasource.select()  # TODO add the correct arguments for the datasource's method call
         return results
 
+    ## @brief prepares the field list
+    # @return list
+    # @raise LeApiDataCheckError
     def __prepare_field_list(self):
         errors = dict()
         ret_field_list = list()
         for field in self.field_list:
             if self.is_relational(field):
-                ret = self.__prepare_relational_fields(field)
+                ret = self.__prepare_relational_field(field)
             else:
                 ret = self.__check_field(field)
 
@@ -127,10 +159,15 @@ class LeGetQuery(LeFilteredQuery):
 
         return ret_field_list
 
-    def __prepare_relational_fields(self, field):
+    ## @brief prepares a relational field
+    def __prepare_relational_field(self, field):
         # TODO Implement the method
         return field
 
+    ## @brief splits the filter string into a tuple (FIELD, OPERATOR, VALUE)
+    # @param filter str
+    # @return tuple
+    # @raise ValueError
     def __split_filter(self, filter):
         if self.query_re is None:
             self.__compile_query_re()
@@ -153,11 +190,17 @@ class LeGetQuery(LeFilteredQuery):
         op_re_piece += ')'
         self.query_re = re.compile('^\s*(?P<field>(((superior)|(subordinate))\.)?[a-z_][a-z0-9\-_]*)\s*'+op_re_piece+'\s*(?P<value>[^<>=!].*)\s*$', flags=re.IGNORECASE)
 
-    def __check_field(self, target_object, field):
-        if field not in self.target_object.fieldnames():
-            return ValueError("No such field '%s' in %s" % (field, self.target_object.__class__))
+    ## @brief checks if a field is in the target class of the query
+    # @param field str
+    # @return str
+    # @raise ValueError
+    def __check_field(self, field):
+        if field not in self.target_class.fieldnames():
+            return ValueError("No such field '%s' in %s" % (field, self.target_class))
         return field
 
+    ## @brief Prepares the filters (relational and others)
+    # @return tuple
     def __prepare_filters(self):
         filters = list()
         errors = dict()
@@ -173,7 +216,7 @@ class LeGetQuery(LeFilteredQuery):
 
         for field, operator, value in filters:
             # TODO check the relation filters
-            ret = self.__check_field(self.target_object, field)
+            ret = self.__check_field(field)
             if isinstance(ret, Exception):
                 errors[field] = ret
             else:
@@ -188,9 +231,11 @@ class LeGetQuery(LeFilteredQuery):
         datas = dict()
         if LeFilteredQuery.validate_query_filters(self.query_filters):
             datas['query_filters'] = self.query_filters
-        datas['target_object'] = self.target_object
+        datas['target_class'] = self.target_class
         return datas
 
+    ## @brief prepares the "order" parameters
+    # @return list
     def __prepare_order(self):
         errors = dict()
         result = []
@@ -200,14 +245,14 @@ class LeGetQuery(LeFilteredQuery):
             if len(order_field) != 2 or order_field[1].upper() not in ['ASC', 'DESC']:
                 errors[order_field] = ValueError("Expected a string or a tuple with (FIELDNAME, ['ASC'|'DESC']) but got : %s" % order_field)
             else:
-                ret = self._target_class.check_field(order_field[0])
+                ret = self.target_class.check_field(order_field[0])
                 if isinstance(ret, Exception):
                     errors[order_field] = ret
             order_field = (order_field[0], order_field[1].upper())
             result.append(order_field)
 
         if len(errors) > 0:
-            return LeApiErrors("Errors when preparing ordering fields", errors)
+            raise LeApiErrors("Errors when preparing ordering fields", errors)
         return result
 
 
@@ -217,7 +262,6 @@ class LeUpdateQuery(LeFilteredQuery):
         super().__init__(target_class)
         self.query_filters = query_filters
         self.target_uid = target_uid
-        self.target_object = None  # TODO get an instance of the target_class using a unique id
 
     def execute(self):
         # LodelHook.call_hook('leapi_update_pre', self.target_object, None)
@@ -230,7 +274,7 @@ class LeUpdateQuery(LeFilteredQuery):
     # @TODO change the behavior in case of error in the update process
     def __update(self):
         updated_datas = self.__prepare()
-        ret = self._datasource.update(self.target_uid, **updated_datas)  # TODO add the correct arguments for the datasource's method call
+        ret = self.datasource.update(self.target_uid, **updated_datas)  # TODO add the correct arguments for the datasource's method
         if ret == 1:
             return True
         else:
@@ -276,4 +320,4 @@ class LeDeleteQuery(LeFilteredQuery):
         datas['target_uid'] = self.target_uid
         datas['target_class'] = self._target_class
 
-        return datas
+        return datas

lodel/plugins.py

@@ -0,0 +1,72 @@
+#-*- coding: utf-8 -*-
+
+import os.path
+
+from importlib.machinery import SourceFileLoader, SourcelessFileLoader
+
+## @package lodel.plugins Lodel2 plugins management
+#
+# Lodel2 plugins are stored in directories
+# A typicall lodel2 plugin directory structure looks like :
+# - {{__init__.py}}} containing informations like full_name, authors, licence etc.
+# - main.py containing hooks registration etc
+# - confspec.py containing a configuration specification dictionary named CONFSPEC
+
+VIRTUAL_PACKAGE_NAME = 'lodel.plugins_pkg'
+CONFSPEC_NAME = 'confspec.py'
+
+class Plugins(object):
+    
+    ## @brief Stores plugin directories paths
+    _plugin_directories = None
+    ## @brief Optimisation cache storage for plugin paths
+    _plugin_paths = dict()
+
+    def __init__(self):
+        self.started()
+    
+    ## @brief Given a plugin name returns the plugin path
+    # @param plugin_name str : The plugin name
+    # @return the plugin directory path
+    @classmethod
+    def plugin_path(cls, plugin_name):
+        cls.started()
+        try:
+            return cls._plugin_paths[plugin_name]
+        except KeyError:
+            pass
+        
+        path = None
+        for cur_path in cls._plugin_directories:
+            plugin_path = os.path.join(cur_path, plugin_name)+'/'
+            print(plugin_path)
+            if os.path.isdir(plugin_path):
+                return plugin_path
+        raise NameError("No plugin named '%s'" % plugin_name)
+
+    ## @brief Fetch a confspec given a plugin_name
+    # @param plugin_name str : The plugin name
+    # @return a dict of conf spec
+    @classmethod
+    def get_confspec(cls, plugin_name):
+        cls.started()
+        plugin_path = cls.plugin_path(plugin_name)
+        plugin_module = '%s.%s' % ( VIRTUAL_PACKAGE_NAME,
+                                    plugin_name)
+        conf_spec_module = plugin_module + '.confspec'
+        
+        conf_spec_source = plugin_path + CONFSPEC_NAME
+
+        loader = SourceFileLoader(conf_spec_module, conf_spec_source)
+        confspec_module = loader.load_module()
+        return getattr(confspec_module, 'CONFSPEC')
+
+    @classmethod
+    def bootstrap(cls, plugins_directories):
+        cls._plugin_directories = plugins_directories
+
+    @classmethod
+    def started(cls, raise_if_not = True):
+        res = cls._plugin_directories is not None
+        if raise_if_not and not res:
+            raise RuntimeError("Class Plugins is not initialized")

lodel/settings.py

@@ -1,145 +0,0 @@
-#-*- coding: utf-8 -*-
-
-import types
-import warnings
-from . import settings_format
-
-## @package Lodel.settings
-#
-# @brief Defines stuff to handles Lodel2 configuration (see @ref lodel_settings )
-#
-# To access the confs use the Lodel.settings.Settings SettingsHandler instance
-
-## @brief A class designed to handles Lodel2 settings
-#
-# When instanciating a SettingsHandler, the new instance is filled with the content of settings.py (in the root directory of lodel2
-#
-# @warning You don't have to instanciate this class, you can access to the global instance with the Settings variable in this module
-# @todo broken stuff... Rewrite it
-# @todo Forbid module assignement in settings ! and disable tests about this
-# @todo Implements a type checking of config value
-# @todo Implements default values for config keys
-class SettingsHandler(object):
-    
-    ## @brief Shortcut
-    _allowed = settings_format.ALLOWED + settings_format.MANDATORY
-    ## @brief Shortcut
-    _mandatory = settings_format.MANDATORY
-
-    def __init__(self):
-        try:
-            import settings as default_settings
-            self._load_module(default_settings)
-        except ImportError:
-            warnings.warn("Unable to find global default settings")
-
-        ## @brief A flag set to True when the instance is fully loaded
-        self._set_loaded(False if len(self._missings()) > 0 else True)
-    
-    ## @brief Compat wrapper for getattr
-    def get(self, name):
-        return getattr(self, name)
-    
-    ## @brief Compat wrapper for setattr
-    def set(self, name, value):
-        return setattr(self, name, value)
-
-    ## @brief Load every module properties in the settings instance
-    #
-    # Load a module content into a SettingsHandler instance and checks that no mandatory settings are missing
-    # @note Example : <pre> import my_cool_settings;
-    # Settings._load_module(my_cool_settings);</pre>
-    # @param module module|None: a loaded module (if None just check for missing settings)
-    # @throw LookupError if invalid settings found or if mandatory settings are missing
-    def load_module(self, module = None):
-        if not(module is None):
-            self._load_module(module)
-        missings = self._missings()
-        if len(missings) > 0:
-            self._loaded = False
-            raise LookupError("Mandatory settings are missing : %s"%missings)
-        self._set_loaded(True)
-    
-    ## @brief supersede of default __setattr__ method
-    def __setattr__(self, name, value):
-        if not hasattr(self, name):
-            if name not in self._allowed:
-                raise LookupError("Invalid setting : %s"%name)
-        super().__setattr__(name, value)
-
-    ## @brief This method do the job for SettingsHandler.load_module()
-    #
-    # @note The difference with SettingsHandler.load_module() is that it didn't check if some settings are missing
-    # @throw LokkupError if an invalid settings is given
-    # @param module : a loaded module
-    def _load_module(self, module):
-        errors = []
-        fatal_errors = []
-        conf_dict = {
-            name: getattr(module, name)
-            for name in dir(module) 
-            if not name.startswith('__') and not isinstance(getattr(module, name), types.ModuleType)
-        }
-        for name, value in conf_dict.items():
-            try:
-                setattr(self, name, value)
-            except LookupError:
-                errors.append(name)
-        if len(errors) > 0:
-            err_msg = "Found invalid settings in %s : %s"%(module.__name__, errors)
-            raise LookupError(err_msg)
-
-    ## @brief Refresh the allowed and mandatory settings list
-    @classmethod
-    def _refresh_format(cls):
-        ## @brief Shortcut
-        cls._allowed = settings_format.ALLOWED + settings_format.MANDATORY
-        ## @brief Shortcut
-        cls._mandatory = settings_format.MANDATORY
-
-    ## @brief If some settings are missings return their names
-    # @return an array of string
-    def _missings(self):
-        return [ confname for confname in self._mandatory if not hasattr(self, confname) ]
-
-    def _set_loaded(self, value):
-        super().__setattr__('_loaded', bool(value))
-
-Settings = SettingsHandler()
-
-## @page lodel_settings Lodel SettingsHandler
-#
-# This page describe the way settings are handled in Lodel2.
-#
-# @section lodel_settings_files Lodel settings files
-#
-# - Lodel/settings.py defines the Lodel.settings package, the SettingsHandler class and the Lodel.settings.Settings instance
-# - Lodel/settings_format.py defines the mandatory and allowed configurations keys lists
-# - install/instance_settings.py is a model of the file that will be deployed in Lodel2 instances directories
-#
-# @section Using Lodel.settings.Settings SettingsHandler instance
-#
-# @subsection lodel_settings_without_loader Without loader
-#
-# Without any loader you can import Lodel.settings.Settings and acces its property with getattr (or . ) or with SettingsHandler.get() method.
-# In the same way you can set a settings by standart affectation of a propery or with SettingsHandler.set() method.
-#
-# @subsection lodel_settings_loader With a loader in a lodel2 instance
-#
-# The loader will import Lodel.settings.Settings and then calls the SettingsHandler.load_module() method to load the content of the instance_settings.py file into the SettingsHandler instance
-#
-# @subsection lodel_settings_example Examples
-#
-# <pre>
-# #!/usr/bin/python
-# from Lodel.settings import Settings
-# if Settings.debug:
-#   print("DEBUG")
-# # or
-# if Settings.get('debug'):
-#   print("DEBUG")
-# Settings.debug = False
-# # or
-# Settings.set('debug', False)
-# </pre>
-# 

lodel/settings/settings.py

@@ -0,0 +1,102 @@
+#-*- coding: utf-8 -*-
+
+import sys
+import os
+import configparser
+
+from lodel.plugins import Plugins
+from lodel.settings.utils import SettingsError, SettingsErrors
+from lodel.settings.validator import SettingValidator
+from lodel.settings.settings_loader import SettingsLoader
+
+## @package lodel.settings Lodel2 settings package
+#
+# Contains all module that help handling settings
+
+## @package lodel.settings.settings Lodel2 settings module
+#
+# Handles configuration load/parse/check.
+#
+# @subsection Configuration load process
+#
+# The configuration load process is not trivial. In fact loaded plugins are able to add their own options.
+# But the list of plugins to load and the plugins options are in the same file, the instance configuration file.
+#
+# @subsection Configuration specification
+#
+# Configuration specification is divided in 2 parts :
+# - default values
+# - value validation/cast (see @ref Lodel.settings.validator.ConfValidator )
+# 
+
+PYTHON_SYS_LIB_PATH = '/usr/local/lib/python{major}.{minor}/'.format(
+
+                                                                        major = sys.version_info.major,
+                                                                        minor = sys.version_info.minor)
+## @brief Handles configuration load etc.
+class Settings(object):
+    
+    ## @brief global conf specsification (default_value + validator)
+    _conf_preload = {
+            'lib_path': (   PYTHON_SYS_LIB_PATH+'/lodel2/',
+                            SettingValidator('directory')),
+            'plugins_path': (   PYTHON_SYS_LIB_PATH+'lodel2/plugins/',
+                                SettingValidator('directory_list')),
+    }
+    
+    def __init__(self, conf_file = '/etc/lodel2/lodel2.conf', conf_dir = 'conf.d'):
+        self.__confs = dict()
+        
+        self.__load_bootstrap_conf(conf_file)
+        # now we should have the self.__confs['lodel2']['plugins_paths'] and
+        # self.__confs['lodel2']['lib_path'] set
+        self.__bootstrap()
+    
+    ## @brief This method handlers Settings instance bootstraping
+    def __bootstrap(self):
+        #loader = SettingsLoader(self.__conf_dir)
+
+        # Starting the Plugins class
+        Plugins.bootstrap(self.__confs['lodel2']['plugins_path'])
+        specs = Plugins.get_confspec('dummy')
+        print("Got specs : %s " % specs)
+        
+        # then fetch options values from conf specs
+    
+    ## @brief Load base global configurations keys
+    #
+    # Base configurations keys are :
+    # - lodel2 lib path
+    # - lodel2 plugins path
+    #
+    # @note return nothing but set the __confs attribute
+    # @see Settings._conf_preload
+    def __load_bootstrap_conf(self, conf_file):
+        config = configparser.ConfigParser()
+        config.read(conf_file)
+        sections = config.sections()
+        if len(sections) != 1 or sections[0].lower() != 'lodel2':
+            raise SettingsError("Global conf error, expected lodel2 section not found")
+        
+        #Load default values in result
+        res = dict()
+        for keyname, (keyvalue, validator) in self._conf_preload.items():
+            res[keyname] = keyvalue
+
+        confs = config[sections[0]]
+        errors = []
+        for name in confs:
+            if name not in res:
+                errors.append(  SettingsError(
+                                    "Unknow field",
+                                    "lodel2.%s" % name,
+                                    conf_file))
+            try:
+                res[name] = self._conf_preload[name][1](confs[name])
+            except Exception as e:
+                errors.append(SettingsError(str(e), name, conf_file))
+        if len(errors) > 0:
+            raise SettingsErrors(errors)
+        
+        self.__confs['lodel2'] = res
+

lodel/settings/utils.py

@@ -22,4 +22,23 @@ class SettingsError(Exception):
 
         res += ": %s" % (self.__msg)
         return res
+
+## @brief Designed to handles mutliple SettingsError
+class SettingsErrors(Exception):
+    
+    ## @brief Instanciate an SettingsErrors
+    # @param exceptions list : list of SettingsError instance
+    def __init__(self, exceptions):
+        for expt in exceptions: 
+            if not isinstance(expt, SettingsError):
+                raise ValueError("The 'exceptions' argument has to be an array of <class SettingsError>, but a %s was found in the list" % type(expt))
+        self.__exceptions = exceptions
         
+
+    def __repr__(self): return str(self)
+
+    def __str__(self):
+        res = "Errors :\n"
+        for expt in self.__exceptions:
+            res += "\t%s\n" % str(expt)
+        return res

lodel/settings/validator.py

@@ -0,0 +1,181 @@
+#-*- coding: utf-8 -*-
+
+import sys
+import os.path
+import re
+import inspect
+import copy
+
+## @package lodel.settings.validator Lodel2 settings validators/cast module
+#
+# Validator are registered in the SettingValidator class.
+
+class SettingsValidationError(Exception):
+    pass
+
+## @brief Handles settings validators
+#
+# Class instance are callable objects that takes a value argument (the value to validate). It raises
+# a SettingsValidationError if validation fails, else it returns a properly
+# casted value.
+class SettingValidator(object):
+    
+    _validators = dict()
+    _description = dict()
+    
+    ## @brief Instanciate a validator
+    def __init__(self, name, none_is_valid = False):
+        if name is not None and name not in self._validators:
+            raise NameError("No validator named '%s'" % name)
+        self.__name = name
+
+    ## @brief Call the validator
+    # @param value *
+    # @return properly casted value
+    # @throw SettingsValidationError
+    def __call__(self, value):
+        if self.__name is None:
+            return value
+        try:
+            return self._validators[self.__name](value)
+        except Exception as e:
+            raise SettingsValidationError(e)
+    
+    ## @brief Register a new validator
+    # @param name str : validator name
+    # @param callback callable : the function that will validate a value
+    @classmethod
+    def register_validator(cls, name, callback, description=None):
+        if name in cls._validators:
+            raise NameError("A validator named '%s' allready exists" % name)
+        # Broken test for callable
+        if not inspect.isfunction(callback) and not inspect.ismethod(callback) and not hasattr(callback, '__call__'):
+            raise TypeError("Callable expected but got %s" % type(callback))
+        cls._validators[name] = callback
+        cls._description[name] = description
+    
+    ## @brief Get the validator list associated with description
+    @classmethod
+    def validators_list(cls):
+        return copy.copy(cls._description)
+
+    ## @brief Create and register a list validator
+    # @param elt_validator callable : The validator that will be used for validate each elt value
+    # @param validator_name str
+    # @param description None | str
+    # @param separator str : The element separator
+    # @return A SettingValidator instance
+    @classmethod
+    def create_list_validator(cls, validator_name, elt_validator, description = None, separator = ','):
+        def list_validator(value):
+            res = list()
+            errors = list()
+            for elt in value.split(separator):
+                res.append(elt_validator(elt))
+            return res
+        description = "Convert value to an array" if description is None else description
+        cls.register_validator(
+                                validator_name,
+                                list_validator,
+                                description)
+        return cls(validator_name)
+                
+    ## @brief Create and register a regular expression validator
+    # @param pattern str : regex pattern
+    # @param validator_name str : The validator name
+    # @param description str : Validator description
+    # @return a SettingValidator instance
+    @classmethod
+    def create_re_validator(cls, pattern, validator_name, description = None):
+        def re_validator(value):
+            if not re.match(pattern, value):
+                raise SettingsValidationError("The value '%s' doesn't match the following pattern '%s'" % pattern)
+            return value
+        #registering the validator
+        cls.register_validator(
+                                validator_name,
+                                re_validator,
+                                ("Match value to '%s'" % pattern) if description is None else description)
+        return cls(validator_name)
+
+    
+    ## @return a list of registered validators
+    def validators_list_str(cls):
+        result = ''
+        for name in cls._validators:
+            result += "\t%s" % name
+            if name in self._description and self._description[name] is not None:
+                result += "\t: %s" % self._description[name]
+            result += "\n"
+        return result
+
+## @brief Integer value validator callback
+def int_val(value):
+    return int(value)
+
+## @brief Output file validator callback
+# @return A file object (if filename is '-' return sys.stderr)
+def file_err_output(value):
+    if not isinstance(value, str):
+        raise SettingsValidationError("A string was expected but got '%s' " % value)
+    if value == '-':
+        return sys.stderr
+    return value
+
+## @brief Boolean value validator callback
+def boolean_val(value):
+    if not (value is True) and not (value is False):
+        raise SettingsValidationError("A boolean was expected but got '%s' " % value)
+    return bool(value)
+
+def directory_val(value):
+    res = SettingValidator('strip')(value)
+    if not os.path.isdir(res):
+        raise SettingsValidationError("Folowing path don't exists or is not a directory : '%s'"%res)
+    return res
+
+#
+#   Default validators registration
+#
+
+SettingValidator.register_validator(
+                                        'strip',
+                                        str.strip,
+                                        'String trim')
+
+SettingValidator.register_validator(
+                                        'int',
+                                        int_val,
+                                        'Integer value validator')
+
+SettingValidator.register_validator(
+                                        'bool',
+                                        boolean_val,
+                                        'Boolean value validator')
+
+SettingValidator.register_validator(
+                                        'errfile',
+                                        file_err_output,
+                                        'Error output file validator (return stderr if filename is "-")')
+
+SettingValidator.register_validator(
+                                        'directory',
+                                        directory_val,
+                                        'Directory path validator')
+
+SettingValidator.create_list_validator(
+                                            'list',
+                                            SettingValidator('strip'),
+                                            description = "Simple list validator. Validate a list of values separated by ','",
+                                            separator = ',')
+
+SettingValidator.create_list_validator(
+                                            'directory_list',
+                                            SettingValidator('directory'),
+                                            description = "Validator for a list of directory path separated with ','",
+                                            separator = ',')
+
+SettingValidator.create_re_validator(
+                                        r'^https?://[^\./]+.[^\./]+/?.*$',
+                                        'http_url',
+                                        'Url validator')

lodel/settings_format.py

@@ -1,26 +0,0 @@
-#-*- coding: utf-8 -*-
-## @package Lodel.settings_format Rules for settings
-
-## @brief List mandatory configurations keys
-MANDATORY = [
-    'debug',
-    'debug_sql',
-    'sitename',
-    'lodel2_lib_path',
-    'em_file',
-    'dynamic_code_file',
-    'ds_package',
-    'datasource',
-    'mh_classname',
-    'migration_options',
-    'base_path',
-    'plugins',
-    'logging',
-]
-
-## @brief List allowed (but not mandatory) configurations keys
-ALLOWED = [
-    'em_graph_output',
-    'em_graph_format',
-    'templates_base_dir'
-]

plugins/dummy/confspec.py

@@ -0,0 +1,7 @@
+#-*- coding: utf-8 -*-
+
+CONFSPEC = {
+    'section1': {
+        'key1': None
+    }
+}

settings.ini

@@ -0,0 +1,3 @@
+[lodel2]
+lib_path = /home/yannweb/dev/lodel2/lodel2-git
+plugins_path = /home/yannweb/dev/lodel2/lodel2-git/plugins