add global 'empty' property, this property raise mandatory PropertiesOptionError if multi or master have empty value

tiramisu/option/baseoption.py

@@ -99,7 +99,7 @@ class Base(StorageBase):
     def __init__(self, name, doc, default=None, default_multi=None,
                  requires=None, multi=False, callback=None,
                  callback_params=None, validator=None, validator_params=None,
-                 properties=None, warnings_only=False, extra=None, allow_empty_list=False):
+                 properties=None, warnings_only=False, extra=None, allow_empty_list=undefined):
         if not valid_name(name):  # pragma: optional cover
             raise ValueError(_("invalid name: {0} for option").format(name))
         if requires is not None:
@@ -900,7 +900,7 @@ class SymLinkOption(OnlyOption):
                                'for symlink {0}').format(name))
         super(Base, self).__init__(name, undefined, undefined, undefined,
                                    undefined, undefined, undefined, undefined,
-                                   False, opt)
+                                   undefined, opt)
         self.commit()
 
     def __getattr__(self, name, context=undefined):

tiramisu/setting.py

@@ -75,6 +75,9 @@ everything_frozen
     whole option in config are frozen (even if option have not frozen
     property)
 
+empty
+    raise mandatory PropertiesOptionError if multi or master have empty value
+
 validator
     launch validator set by user in option (this property has no effect
     for internal validator)
@@ -97,10 +100,10 @@ read_write
     you can set all variables not frozen
 """
 ro_append = set(['frozen', 'disabled', 'validator', 'everything_frozen',
-                'mandatory'])
+                'mandatory', 'empty'])
 ro_remove = set(['permissive', 'hidden'])
 rw_append = set(['frozen', 'disabled', 'validator', 'hidden'])
-rw_remove = set(['permissive', 'everything_frozen', 'mandatory'])
+rw_remove = set(['permissive', 'everything_frozen', 'mandatory', 'empty'])
 
 
 forbidden_set_properties = set(['force_store_value'])
@@ -468,8 +471,13 @@ class Settings(object):
         else:
             if 'mandatory' in properties and \
                     not self._getcontext().cfgimpl_get_values()._isempty(
-                        opt_or_descr, value, opt_or_descr.impl_allow_empty_list()):
+                        opt_or_descr, value):
                 properties.remove('mandatory')
+            elif not is_write and 'empty' in forced_properties and \
+                    not opt_or_descr.impl_is_master_slaves('slave') and \
+                    self._getcontext().cfgimpl_get_values()._isempty(
+                        opt_or_descr, value, force_allow_empty_list=True):
+                properties.add('mandatory')
             if is_write and 'everything_frozen' in forced_properties:
                 properties.add('frozen')
             elif 'frozen' in properties and not is_write:

tiramisu/storage/dictionary/option.py

@@ -79,7 +79,7 @@ class StorageBase(object):
             self._properties = properties
         if opt is not undefined:
             self._opt = opt
-        if allow_empty_list is not False:
+        if allow_empty_list is not undefined:
             self._allow_empty_list = allow_empty_list
 
     def _set_default_values(self, default, default_multi):
@@ -302,8 +302,7 @@ class StorageBase(object):
         try:
             return self._allow_empty_list
         except AttributeError:
-            return False
-
+            return undefined
 
     def _get_extra(self, key):
         extra = self._extra

tiramisu/value.py

@@ -175,18 +175,27 @@ class Values(object):
         if hasvalue:
             self._p_.resetvalue(path)
 
-    def _isempty(self, opt, value, allow_empty_list):
+    def _isempty(self, opt, value, force_allow_empty_list=False):
         "convenience method to know if an option is empty"
-        empty = opt._empty
-        if value is not undefined:
-            empty_not_multi = not opt.impl_is_multi() and (value is None or
-                                                           value == empty)
-            empty_multi = opt.impl_is_multi() and ((not allow_empty_list and value == []) or
-                                                   None in value or
-                                                   empty in value)
+        if value is undefined:
+            return False
         else:
-            empty_multi = empty_not_multi = False
-        return empty_not_multi or empty_multi
+            empty = opt._empty
+            if opt.impl_is_multi():
+                if force_allow_empty_list:
+                    allow_empty_list = True
+                else:
+                    allow_empty_list = opt.impl_allow_empty_list()
+                    if allow_empty_list is undefined:
+                        if opt.impl_is_master_slaves('slave'):
+                            allow_empty_list = True
+                        else:
+                            allow_empty_list = False
+                isempty = (not allow_empty_list and value == []) or \
+                    None in value or empty in value
+            else:
+                isempty = value is None or value == empty
+        return isempty
 
     def __getitem__(self, opt):
         "enables us to use the pythonic dictionary-like access to values"