add option name's validation and rename Option method with objimpl_
[tiramisu.git] / tiramisu / value.py
index 528185a..a58dd3b 100644 (file)
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #
 # ____________________________________________________________
-from tiramisu.error import MandatoryError, MultiTypeError, \
-    ConfigError, ValidateError
-from tiramisu.setting import owners, multitypes
+from time import time
+from tiramisu.error import ConfigError, SlaveError
+from tiramisu.setting import owners, multitypes, expires_time
 from tiramisu.autolib import carry_out_calculation
+from tiramisu.i18n import _
 
 
 class Values(object):
-    __slots__ = ('values', 'context')
+    __slots__ = ('context', '_values', '_cache')
 
     def __init__(self, context):
         """
@@ -33,82 +34,44 @@ class Values(object):
         :param context: the context is the home config's values
         """
         "Config's root indeed is in charge of the `Option()`'s values"
-        self.values = {}
         self.context = context
+        self._values = {}
+        self._cache = {}
+        super(Values, self).__init__()
 
     def _get_value(self, opt):
         "return value or default value if not set"
         #if no value
-        if opt not in self.values:
-            value = opt.getdefault()
-            if opt.is_multi():
+        if opt not in self._values:
+            value = opt.objimpl_getdefault()
+            if opt.objimpl_is_multi():
                 value = Multi(value, self.context, opt)
-                #if slave, had values until master's one
-                if opt.get_multitype() == multitypes.slave:
-                    masterpath = self.context.cfgimpl_get_description().get_path_by_opt(opt.get_master_slaves())
-                    mastervalue = getattr(self.context, masterpath)
-                    masterlen = len(mastervalue)
-                    if len(value) > masterlen:
-                        raise MultiTypeError("invalid len for the slave: {0}"
-                                             " which has {1} as master".format(
-                                                 opt._name, masterpath))
-                    if len(value) < masterlen:
-                        for num in range(0, masterlen - len(value)):
-                            value.append(opt.getdefault_multi(), force=True)
-                    #FIXME si inferieur ??
         else:
             #if value
-            value = self.values[opt][1]
+            value = self._values[opt][1]
         return value
 
-    def reset(self, opt):
-        if opt in self.values:
-            del(self.values[opt])
+    def __delitem__(self, opt):
+        self._reset(opt)
+
+    def _reset(self, opt):
+        if opt in self._values:
+            self.context.cfgimpl_reset_cache()
+            del(self._values[opt])
 
     def _is_empty(self, opt, value):
         "convenience method to know if an option is empty"
-        #FIXME: buggy ?
-        #if value is not None:
-        #    return False
-        if (not opt.is_multi() and value is None) or \
-           (opt.is_multi() and (value == [] or
-                                None in self._get_value(opt))):
+        empty = opt._empty
+        if (not opt.objimpl_is_multi() and (value is None or value == empty)) or \
+           (opt.objimpl_is_multi() and (value == [] or
+                                        None in value or empty in value)):
+            return True
+        if self.is_default_owner(opt) and opt.objimpl_is_empty_by_default():
             return True
         return False
 
-    def _test_mandatory(self, opt, value, force_properties=None):
-        setting = self.context.cfgimpl_get_settings()
-        if force_properties is None:
-            set_mandatory = setting.has_property('mandatory')
-        else:
-            set_mandatory = ('mandatory' in force_properties or
-                             setting.has_property('mandatory'))
-        if setting.has_property('mandatory', opt, False) and set_mandatory:
-            if self._is_empty(opt, value) and opt.is_empty_by_default():
-                raise MandatoryError("option: {0} is mandatory "
-                                     "and shall have a value".format(opt._name))
-            #empty value
-            if opt.is_multi():
-                for val in value:
-                    if val == '':
-                        raise MandatoryError("option: {0} is mandatory "
-                                             "and shall have not empty value".format(opt._name))
-            else:
-                if value == '':
-                    raise MandatoryError("option: {0} is mandatory "
-                                         "and shall have not empty value".format(opt._name))
-
-    def fill_multi(self, opt, result):
-        """fills a multi option with default and calculated values
-        """
-        if not isinstance(result, list):
-            _result = [result]
-        else:
-            _result = result
-        return Multi(_result, self.context, opt)  # , multitype)
-
     def _getcallback_value(self, opt):
-        callback, callback_params = opt.callback
+        callback, callback_params = opt._callback
         if callback_params is None:
             callback_params = {}
         return carry_out_calculation(opt._name, config=self.context,
@@ -116,84 +79,89 @@ class Values(object):
                                      callback_params=callback_params)
 
     def __getitem__(self, opt):
-        return self._getitem(opt)
+        return self.getitem(opt)
+
+    def getitem(self, opt, validate=True, force_permissive=False,
+                force_properties=None):
+        if opt in self._cache:
+            exp = time()
+            value, created = self._cache[opt]
+            if exp < created:
+                return value
+        val = self._getitem(opt, validate, force_permissive, force_properties)
+        self._set_cache(opt, val)
+        return val
 
-    def _getitem(self, opt, force_properties=None, validate=True):
+    def _getitem(self, opt, validate, force_permissive, force_properties):
         # options with callbacks
-        value = self._get_value(opt)
         setting = self.context.cfgimpl_get_settings()
-        is_frozen = setting.has_property('frozen', opt, False)
-        if opt.has_callback():
+        value = self._get_value(opt)
+        is_frozen = 'frozen' in setting[opt]
+        if opt.objimpl_has_callback():
             #if value is set and :
             # - not frozen
             # - frozen and not force_default_on_freeze
             if not self.is_default_owner(opt) and (
                     not is_frozen or (is_frozen and
-                                      not setting.has_property('force_default_on_freeze', opt, False))):
+                                      not 'force_default_on_freeze' in setting[opt])):
                 pass
             else:
                 value = self._getcallback_value(opt)
-                if opt.is_multi():
-                    value = self.fill_multi(opt, value)
+                if opt.objimpl_is_multi():
+                    value = Multi(value, self.context, opt)
                 #suppress value if already set
-                self.reset(opt)
+                self._reset(opt)
         # frozen and force default
-        elif is_frozen and setting.has_property('force_default_on_freeze', opt, False):
-            value = opt.getdefault()
-            if opt.is_multi():
-                value = self.fill_multi(opt, value)
-        self._test_mandatory(opt, value, force_properties)
-        if validate and not opt.validate(value, self.context, setting.has_property('validator')):
-            raise ValidateError('invalid calculated value returned'
-                                ' for option {0}: {1}'.format(opt._name, value))
+        elif is_frozen and 'force_default_on_freeze' in setting[opt]:
+            value = opt.objimpl_getdefault()
+            if opt.objimpl_is_multi():
+                value = Multi(value, self.context, opt)
+        if validate and not opt.objimpl_validate(value, self.context, 'validator' in setting):
+            raise ValueError(_('invalid calculated value returned'
+                             ' for option {0}: {1}').format(opt._name, value))
+        if self.is_default_owner(opt) and \
+                'force_store_value' in setting[opt]:
+            self.setitem(opt, value)
+        setting.validate_properties(opt, False, False, value=value,
+                                    force_permissive=force_permissive,
+                                    force_properties=force_properties)
         return value
 
     def __setitem__(self, opt, value):
-        if not opt.validate(value, self.context,
-                            self.context.cfgimpl_get_settings().has_property('validator')):
-            raise ValidateError('invalid value {}'
-                                ' for option {}'.format(value, opt._name))
-        if opt.is_multi():
-            if opt.get_multitype() == multitypes.master:
-                masterlen = len(value)
-                for slave in opt.master_slaves:
-                    value_slave = self._get_value(slave)
-                    if len(value_slave) > masterlen:
-                        raise MultiTypeError("invalid len for the slave: {0}"
-                                             " which has {1} as master".format(
-                                                 slave._name, opt._name))
-                    elif len(value_slave) < masterlen:
-                        for num in range(0, masterlen - len(value_slave)):
-                            value_slave.append(slave.getdefault_multi(), force=True)
-
-            elif opt.get_multitype() == multitypes.slave:
-                if len(self._get_value(opt.master_slaves)) != len(value):
-                    raise MultiTypeError("invalid len for the slave: {0}"
-                                         " which has {1} as master".format(
-                                             opt._name, opt.master_slaves._name))
-            if not isinstance(value, Multi):
-                value = Multi(value, self.context, opt)
         self.setitem(opt, value)
 
-    def setitem(self, opt, value):
-        if type(value) == list:
-            raise MultiTypeError("the type of the value {0} which is multi shall "
-                                 "be Multi and not list".format(str(value)))
-        self._test_mandatory(opt, value)
-        self.values[opt] = (self.context.cfgimpl_get_settings().getowner(), value)
+    def setitem(self, opt, value, force_permissive=False):
+        self._setitem(opt, value, force_permissive)
 
-    def __contains__(self, opt):
-        return opt in self.values
+    def _setitem(self, opt, value, force_permissive=False, force_properties=None):
+        #valid opt
+        if not opt.objimpl_validate(value, self.context,
+                                    'validator' in self.context.cfgimpl_get_settings()):
+            raise ValueError(_('invalid value {}'
+                             ' for option {}').format(value, opt._name))
+        if opt.objimpl_is_multi() and not isinstance(value, Multi):
+            value = Multi(value, self.context, opt)
+        self._setvalue(opt, value, force_permissive=force_permissive,
+                       force_properties=force_properties)
+
+    def _setvalue(self, opt, value, force_permissive=False, force_properties=None):
+        self.context.cfgimpl_reset_cache()
+        setting = self.context.cfgimpl_get_settings()
+        setting.validate_properties(opt, False, True,
+                                    value=value,
+                                    force_permissive=force_permissive,
+                                    force_properties=force_properties)
+        self._values[opt] = (setting.getowner(), value)
 
     def getowner(self, opt):
-        return self.values.get(opt, (owners.default, None))[0]
+        return self._values.get(opt, (owners.default, None))[0]
 
     def setowner(self, opt, owner):
-        if opt not in self.values:
-            raise ConfigError('no value for {} cannot change owner to {}'.format(opt))
+        if opt not in self._values:
+            raise ConfigError(_('no value for {1} cannot change owner to {2}').format(opt))
         if not isinstance(owner, owners.Owner):
-            raise TypeError("invalid generic owner {0}".format(str(owner)))
-        self.values[opt] = (owner, self.values[opt][1])
+            raise TypeError(_("invalid generic owner {0}").format(str(owner)))
+        self._values[opt] = (owner, self._values[opt][1])
 
     def is_default_owner(self, opt):
         """
@@ -203,6 +171,24 @@ class Values(object):
         """
         return self.getowner(opt) == owners.default
 
+    def _set_cache(self, opt, val):
+        if 'expire' in self.context.cfgimpl_get_settings():
+            self._cache[opt] = (val, time() + expires_time)
+
+    def reset_cache(self, only_expired):
+        if only_expired:
+            exp = time()
+            keys = self._cache.keys()
+            for key in keys:
+                val, created = self._cache[key]
+                if exp > created:
+                    del(self._cache[key])
+        else:
+            self._cache.clear()
+
+    def __contains__(self, opt):
+        return opt in self._values
+
 # ____________________________________________________________
 # multi types
 
@@ -212,19 +198,58 @@ class Multi(list):
     that support item notation for the values of multi options"""
     __slots__ = ('opt', 'context')
 
-    def __init__(self, lst, context, opt):
+    def __init__(self, value, context, opt):
         """
-        :param lst: the Multi wraps a list value
+        :param value: the Multi wraps a list value
         :param context: the home config that has the values
         :param opt: the option object that have this Multi value
         """
         self.opt = opt
         self.context = context
-        super(Multi, self).__init__(lst)
+        if not isinstance(value, list):
+            value = [value]
+        if self.opt.objimpl_get_multitype() == multitypes.slave:
+            value = self._valid_slave(value)
+        elif self.opt.objimpl_get_multitype() == multitypes.master:
+            self._valid_master(value)
+        super(Multi, self).__init__(value)
+
+    def _valid_slave(self, value):
+        #if slave, had values until master's one
+        masterp = self.context.cfgimpl_get_description().objimpl_get_path_by_opt(
+            self.opt.objimpl_get_master_slaves())
+        mastervalue = getattr(self.context, masterp)
+        masterlen = len(mastervalue)
+        if len(value) > masterlen or (len(value) < masterlen and
+                                      not self.context.cfgimpl_get_values().is_default_owner(self.opt)):
+            raise SlaveError(_("invalid len for the slave: {0}"
+                               " which has {1} as master").format(
+                                   self.opt._name, masterp))
+        elif len(value) < masterlen:
+            for num in range(0, masterlen - len(value)):
+                value.append(self.opt.objimpl_getdefault_multi())
+        #else: same len so do nothing
+        return value
+
+    def _valid_master(self, value):
+        masterlen = len(value)
+        values = self.context.cfgimpl_get_values()
+        for slave in self.opt._master_slaves:
+            if not values.is_default_owner(slave):
+                value_slave = values._get_value(slave)
+                if len(value_slave) > masterlen:
+                    raise SlaveError(_("invalid len for the master: {0}"
+                                       " which has {1} as slave with"
+                                       " greater len").format(
+                                           self.opt._name, slave._name))
+                elif len(value_slave) < masterlen:
+                    for num in range(0, masterlen - len(value_slave)):
+                        value_slave.append(slave.objimpl_getdefault_multi(), force=True)
 
     def __setitem__(self, key, value):
         self._validate(value)
-        self.context.cfgimpl_get_values()[self.opt] = self
+        #assume not checking mandatory property
+        self.context.cfgimpl_get_values()._setvalue(self.opt, self)
         super(Multi, self).__setitem__(key, value)
 
     def append(self, value, force=False):
@@ -232,20 +257,24 @@ class Multi(list):
         only if the option is a master
         """
         if not force:
-            if self.opt.get_multitype() == multitypes.slave:
-                raise MultiTypeError("cannot append a value on a multi option {0}"
-                                     " which is a slave".format(self.opt._name))
-            elif self.opt.get_multitype() == multitypes.master:
-                for slave in self.opt.get_master_slaves():
-                    self.context.cfgimpl_get_values()[slave].append(slave.getdefault_multi(), force=True)
+            if self.opt.objimpl_get_multitype() == multitypes.slave:
+                raise SlaveError(_("cannot append a value on a multi option {0}"
+                                   " which is a slave").format(self.opt._name))
+            elif self.opt.objimpl_get_multitype() == multitypes.master:
+                for slave in self.opt.objimpl_get_master_slaves():
+                    values = self.context.cfgimpl_get_values()
+                    if not values.is_default_owner(slave):
+                        values[slave].append(slave.objimpl_getdefault_multi(),
+                                             force=True)
         self._validate(value)
-        self.context.cfgimpl_get_values().setitem(self.opt, self)
+        #assume not checking mandatory property
+        self.context.cfgimpl_get_values()._setvalue(self.opt, self)
         super(Multi, self).append(value)
 
     def _validate(self, value):
         if value is not None and not self.opt._validate(value):
-            raise ConfigError("invalid value {0} "
-                              "for option {1}".format(str(value),
+            raise ValueError(_("invalid value {0} "
+                             "for option {1}").format(str(value),
                                                       self.opt._name))
 
     def pop(self, key, force=False):
@@ -256,11 +285,11 @@ class Multi(list):
         :return: the requested element
         """
         if not force:
-            if self.opt.multitype == multitypes.slave:
-                raise MultiTypeError("cannot append a value on a multi option {0}"
-                                     " which is a slave".format(self.opt._name))
-            elif self.opt.multitype == multitypes.master:
-                for slave in self.opt.get_master_slaves():
+            if self.opt.objimpl_get_multitype() == multitypes.slave:
+                raise SlaveError(_("cannot pop a value on a multi option {0}"
+                                   " which is a slave").format(self.opt._name))
+            elif self.opt.objimpl_get_multitype() == multitypes.master:
+                for slave in self.opt.objimpl_get_master_slaves():
                     self.context.cfgimpl_get_values()[slave].pop(key, force=True)
-        self.context.cfgimpl_get_values().setitem(self.opt, self)
+        self.context.cfgimpl_get_values()._setvalue(self.opt, self)
         return super(Multi, self).pop(key)