Requires need option, not path
[tiramisu.git] / tiramisu / setting.py
1 # -*- coding: utf-8 -*-
2 "sets the options of the configuration objects Config object itself"
3 # Copyright (C) 2012-2013 Team tiramisu (see AUTHORS for all contributors)
4 #
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 2 of the License, or
8 # (at your option) any later version.
9 #
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 # GNU General Public License for more details.
14 #
15 # You should have received a copy of the GNU General Public License
16 # along with this program; if not, write to the Free Software
17 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 #
19 # The original `Config` design model is unproudly borrowed from
20 # the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
21 # the whole pypy projet is under MIT licence
22 # ____________________________________________________________
23 from time import time
24 from tiramisu.error import RequirementRecursionError, PropertiesOptionError
25 from tiramisu.i18n import _
26
27
28 expires_time = 5
29 ro_remove = ('permissive', 'hidden')
30 ro_append = ('frozen', 'disabled', 'validator', 'everything_frozen', 'mandatory')
31 rw_remove = ('permissive', 'everything_frozen', 'mandatory')
32 rw_append = ('frozen', 'disabled', 'validator', 'hidden')
33
34
35 class _const:
36     """convenient class that emulates a module
37     and builds constants (that is, unique names)"""
38     class ConstError(TypeError):
39         pass
40
41     def __setattr__(self, name, value):
42         if name in self.__dict__:
43             raise self.ConstError, _("Can't rebind group ({})").format(name)
44         self.__dict__[name] = value
45
46     def __delattr__(self, name):
47         if name in self.__dict__:
48             raise self.ConstError, _("Can't unbind group ({})").format(name)
49         raise ValueError(name)
50
51
52 # ____________________________________________________________
53 class GroupModule(_const):
54     "emulates a module to manage unique group (OptionDescription) names"
55     class GroupType(str):
56         """allowed normal group (OptionDescription) names
57         *normal* means : groups that are not master
58         """
59         pass
60
61     class DefaultGroupType(GroupType):
62         """groups that are default (typically 'default')"""
63         pass
64
65     class MasterGroupType(GroupType):
66         """allowed normal group (OptionDescription) names
67         *master* means : groups that have the 'master' attribute set
68         """
69         pass
70 # setting.groups (emulates a module)
71 groups = GroupModule()
72
73
74 def populate_groups():
75     "populates the available groups in the appropriate namespaces"
76     groups.master = groups.MasterGroupType('master')
77     groups.default = groups.DefaultGroupType('default')
78     groups.family = groups.GroupType('family')
79
80 # names are in the module now
81 populate_groups()
82
83
84 # ____________________________________________________________
85 class OwnerModule(_const):
86     """emulates a module to manage unique owner names.
87
88     owners are living in `Config._cfgimpl_value_owners`
89     """
90     class Owner(str):
91         """allowed owner names
92         """
93         pass
94
95     class DefaultOwner(Owner):
96         """groups that are default (typically 'default')"""
97         pass
98 # setting.owners (emulates a module)
99 owners = OwnerModule()
100
101
102 def populate_owners():
103     """populates the available owners in the appropriate namespaces
104
105     - 'user' is the generic is the generic owner.
106     - 'default' is the config owner after init time
107     """
108     setattr(owners, 'default', owners.DefaultOwner('default'))
109     setattr(owners, 'user', owners.Owner('user'))
110
111     def add_owner(name):
112         """
113         :param name: the name of the new owner
114         """
115         setattr(owners, name, owners.Owner(name))
116     setattr(owners, 'add_owner', add_owner)
117
118 # names are in the module now
119 populate_owners()
120
121
122 class MultiTypeModule(_const):
123     class MultiType(str):
124         pass
125
126     class DefaultMultiType(MultiType):
127         pass
128
129     class MasterMultiType(MultiType):
130         pass
131
132     class SlaveMultiType(MultiType):
133         pass
134
135 multitypes = MultiTypeModule()
136
137
138 def populate_multitypes():
139     setattr(multitypes, 'default', multitypes.DefaultMultiType('default'))
140     setattr(multitypes, 'master', multitypes.MasterMultiType('master'))
141     setattr(multitypes, 'slave', multitypes.SlaveMultiType('slave'))
142
143 populate_multitypes()
144
145
146 class Property(object):
147     __slots__ = ('_setting', '_properties', '_opt')
148
149     def __init__(self, setting, prop, opt=None):
150         self._opt = opt
151         self._setting = setting
152         self._properties = prop
153
154     def append(self, propname):
155         if not propname in self._properties:
156             self._properties.append(propname)
157             self._setting._set_properties(self._properties, self._opt)
158         self._setting.context.cfgimpl_reset_cache()
159
160     def remove(self, propname):
161         if propname in self._properties:
162             self._properties.remove(propname)
163             self._setting._set_properties(self._properties, self._opt)
164         self._setting.context.cfgimpl_reset_cache()
165
166     def __contains__(self, propname):
167         return propname in self._properties
168
169     def __repr__(self):
170         return str(self._properties)
171
172
173 #____________________________________________________________
174 class Setting(object):
175     "``Config()``'s configuration options"
176     __slots__ = ('context', '_properties', '_permissives', '_owner', '_cache')
177
178     def __init__(self, context):
179         # properties attribute: the name of a property enables this property
180         # key is None for global properties
181         self._properties = {None: ['expire']}
182         # permissive properties
183         self._permissives = {}
184         # generic owner
185         self._owner = owners.user
186         self.context = context
187         self._cache = {}
188
189     #____________________________________________________________
190     # properties methods
191     def __contains__(self, propname):
192         return propname in self._get_properties()
193
194     def __repr__(self):
195         return str(self._get_properties())
196
197     def __getitem__(self, opt):
198         return Property(self, self._get_properties(opt), opt)
199
200     def __setitem__(self, opt, value):
201         raise ValueError('you must only append/remove properties')
202
203     def _get_properties(self, opt=None, is_apply_req=True):
204         if opt is not None and opt in self._cache:
205             exp = time()
206             props, created = self._cache[opt]
207             if exp < created:
208                 return props
209         if opt is None:
210             default = []
211         else:
212             if is_apply_req:
213                 apply_requires(opt, self.context)
214             default = list(opt._properties)
215         props = self._properties.get(opt, default)
216         if opt is not None:
217             self._set_cache(opt, props)
218         return props
219
220     def append(self, propname):
221         "puts property propname in the Config's properties attribute"
222         Property(self, self._get_properties()).append(propname)
223
224     def remove(self, propname):
225         "deletes property propname in the Config's properties attribute"
226         Property(self, self._get_properties()).remove(propname)
227
228     def _set_properties(self, properties, opt=None):
229         """save properties for specified opt
230         (never save properties if same has option properties)
231         """
232         if opt is None:
233             self._properties[opt] = properties
234         else:
235             if opt._properties == properties:
236                 if opt in self._properties:
237                     del(self._properties[opt])
238             else:
239                 self._properties[opt] = properties
240
241     def _validate_frozen(self, opt, value, is_write):
242         if not is_write:
243             return False
244         if 'permissive' in self and 'frozen' in self._get_permissive():
245             return False
246         if 'everything_frozen' in self or (
247                 'frozen' in self and 'frozen' in self[opt]):
248             return True
249         return False
250
251     def _validate_mandatory(self, opt, value, force_properties):
252         if 'permissive' in self and 'mandatory' in self._get_permissive():
253             return False
254         check_mandatory = 'mandatory' in self
255         if force_properties is not None:
256             check_mandatory = ('mandatory' in force_properties or
257                                check_mandatory)
258         if check_mandatory and 'mandatory' in self[opt] and \
259                 self.context.cfgimpl_get_values()._is_empty(opt, value):
260             return True
261         return False
262
263     def _calc_properties(self, opt_or_descr, force_permissive, force_properties):
264         properties = set(self._get_properties(opt_or_descr))
265         #remove this properties, those properties are validate in after
266         properties = properties - set(['mandatory', 'frozen'])
267         set_properties = set(self._get_properties())
268         if force_properties is not None:
269             set_properties.update(set(force_properties))
270         properties = properties & set_properties
271         if force_permissive is True or 'permissive' in self:
272             properties = properties - set(self._get_permissive())
273         properties = properties - set(self._get_permissive(opt_or_descr))
274         return list(properties)
275
276     #____________________________________________________________
277     def validate_properties(self, opt_or_descr, is_descr, is_write,
278                             value=None, force_permissive=False,
279                             force_properties=None):
280         properties = self._calc_properties(opt_or_descr, force_permissive,
281                                            force_properties)
282         raise_text = _("trying to access"
283                        " to an option named: {0} with properties"
284                        " {1}")
285         if not is_descr:
286             if self._validate_mandatory(opt_or_descr, value, force_properties):
287                 properties.append('mandatory')
288             if self._validate_frozen(opt_or_descr, value, is_write):
289                 properties.append('frozen')
290                 raise_text = _('cannot change the value for '
291                                'option {0} this option is frozen')
292         if properties != []:
293             raise PropertiesOptionError(raise_text.format(opt_or_descr._name,
294                                                           str(properties)),
295                                         properties)
296
297     def _get_permissive(self, opt=None):
298         return self._permissives.get(opt, [])
299
300     def set_permissive(self, permissive, opt=None):
301         if not isinstance(permissive, tuple):
302             raise TypeError(_('permissive must be a tuple'))
303         self._permissives[opt] = permissive
304
305     #____________________________________________________________
306     def setowner(self, owner):
307         ":param owner: sets the default value for owner at the Config level"
308         if not isinstance(owner, owners.Owner):
309             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
310         self._owner = owner
311
312     def getowner(self):
313         return self._owner
314
315     #____________________________________________________________
316     def _read(self, remove, append):
317         for prop in remove:
318             self.remove(prop)
319         for prop in append:
320             self.append(prop)
321
322     def read_only(self):
323         "convenience method to freeze, hidde and disable"
324         self._read(ro_remove, ro_append)
325
326     def read_write(self):
327         "convenience method to freeze, hidde and disable"
328         self._read(rw_remove, rw_append)
329
330     def _set_cache(self, opt, props):
331         if 'expire' in self:
332             self._cache[opt] = (props, time() + expires_time)
333             pass
334
335     def reset_cache(self, only_expired):
336         if only_expired:
337             exp = time()
338             keys = self._cache.keys()
339             for key in keys:
340                 props, created = self._cache[key]
341                 if exp > created:
342                     del(self._cache[key])
343         else:
344             self._cache.clear()
345
346
347 def apply_requires(opt, config):
348     "carries out the jit (just in time requirements between options"
349     def build_actions(requires):
350         "action are hide, show, enable, disable..."
351         trigger_actions = {}
352         for require in requires:
353             action = require[2]
354             trigger_actions.setdefault(action, []).append(require)
355         return trigger_actions
356     #for symlink
357     if hasattr(opt, '_requires') and opt._requires is not None:
358         # filters the callbacks
359         settings = config.cfgimpl_get_settings()
360         setting = Property(settings, settings._get_properties(opt, False), opt)
361         trigger_actions = build_actions(opt._requires)
362         descr = config.cfgimpl_get_context().cfgimpl_get_description()
363         optpath = descr.optimpl_get_path_by_opt(opt)
364         for requires in trigger_actions.values():
365             matches = False
366             for require in requires:
367                 if len(require) == 3:
368                     option, expected, action = require
369                     inverse = False
370                 elif len(require) == 4:
371                     option, expected, action, inverse = require
372                 path = descr.optimpl_get_path_by_opt(option)
373                 if path == optpath or path.startswith(optpath + '.'):
374                     raise RequirementRecursionError(_("malformed requirements "
375                                                     "imbrication detected for option: '{0}' "
376                                                     "with requirement on: '{1}'").format(optpath, path))
377                 try:
378                     value = config.cfgimpl_get_context()._getattr(path, force_permissive=True)
379                 except PropertiesOptionError, err:
380                     properties = err.proptype
381                     raise PropertiesOptionError(_("option '{0}' has requirement's property error: "
382                                                   "{1} {2}").format(opt._name, path, properties), properties)
383                 except AttributeError:
384                     raise AttributeError(_("required option not found: "
385                                          "{0}").format(path))
386                 if value == expected:
387                     if inverse:
388                         setting.remove(action)
389                     else:
390                         setting.append(action)
391                     matches = True
392             # no requirement has been triggered, then just reverse the action
393             if not matches:
394                 if inverse:
395                     setting.append(action)
396                 else:
397                     setting.remove(action)