update translation
[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 copy import copy
25 from tiramisu.error import RequirementError, PropertiesOptionError
26 from tiramisu.i18n import _
27
28 default_encoding = 'utf-8'
29 expires_time = 5
30 ro_remove = ('permissive', 'hidden')
31 ro_append = ('frozen', 'disabled', 'validator', 'everything_frozen', 'mandatory')
32 rw_remove = ('permissive', 'everything_frozen', 'mandatory')
33 rw_append = ('frozen', 'disabled', 'validator', 'hidden')
34 default_properties = ('expire', 'validator')
35
36
37 class _const:
38     """convenient class that emulates a module
39     and builds constants (that is, unique names)"""
40     class ConstError(TypeError):
41         pass
42
43     def __setattr__(self, name, value):
44         if name in self.__dict__:
45             raise self.ConstError, _("can't rebind group ({})").format(name)
46         self.__dict__[name] = value
47
48     def __delattr__(self, name):
49         if name in self.__dict__:
50             raise self.ConstError, _("can't unbind group ({})").format(name)
51         raise ValueError(name)
52
53
54 # ____________________________________________________________
55 class GroupModule(_const):
56     "emulates a module to manage unique group (OptionDescription) names"
57     class GroupType(str):
58         """allowed normal group (OptionDescription) names
59         *normal* means : groups that are not master
60         """
61         pass
62
63     class DefaultGroupType(GroupType):
64         """groups that are default (typically 'default')"""
65         pass
66
67     class MasterGroupType(GroupType):
68         """allowed normal group (OptionDescription) names
69         *master* means : groups that have the 'master' attribute set
70         """
71         pass
72 # setting.groups (emulates a module)
73 groups = GroupModule()
74
75
76 def populate_groups():
77     "populates the available groups in the appropriate namespaces"
78     groups.master = groups.MasterGroupType('master')
79     groups.default = groups.DefaultGroupType('default')
80     groups.family = groups.GroupType('family')
81
82 # names are in the module now
83 populate_groups()
84
85
86 # ____________________________________________________________
87 class OwnerModule(_const):
88     """emulates a module to manage unique owner names.
89
90     owners are living in `Config._cfgimpl_value_owners`
91     """
92     class Owner(str):
93         """allowed owner names
94         """
95         pass
96
97     class DefaultOwner(Owner):
98         """groups that are default (typically 'default')"""
99         pass
100 # setting.owners (emulates a module)
101 owners = OwnerModule()
102
103
104 def populate_owners():
105     """populates the available owners in the appropriate namespaces
106
107     - 'user' is the generic is the generic owner.
108     - 'default' is the config owner after init time
109     """
110     setattr(owners, 'default', owners.DefaultOwner('default'))
111     setattr(owners, 'user', owners.Owner('user'))
112
113     def add_owner(name):
114         """
115         :param name: the name of the new owner
116         """
117         setattr(owners, name, owners.Owner(name))
118     setattr(owners, 'add_owner', add_owner)
119
120 # names are in the module now
121 populate_owners()
122
123
124 class MultiTypeModule(_const):
125     "namespace for the master/slaves"
126     class MultiType(str):
127         pass
128
129     class DefaultMultiType(MultiType):
130         pass
131
132     class MasterMultiType(MultiType):
133         pass
134
135     class SlaveMultiType(MultiType):
136         pass
137
138 multitypes = MultiTypeModule()
139
140
141 def populate_multitypes():
142     "populates the master/slave namespace"
143     setattr(multitypes, 'default', multitypes.DefaultMultiType('default'))
144     setattr(multitypes, 'master', multitypes.MasterMultiType('master'))
145     setattr(multitypes, 'slave', multitypes.SlaveMultiType('slave'))
146
147 populate_multitypes()
148
149
150 class Property(object):
151     "a property is responsible of the option's value access rules"
152     __slots__ = ('_setting', '_properties', '_opt')
153
154     def __init__(self, setting, prop, opt=None):
155         self._opt = opt
156         self._setting = setting
157         self._properties = prop
158
159     def append(self, propname):
160         self._properties.add(propname)
161         self._setting._set_properties(self._properties, self._opt)
162
163     def remove(self, propname):
164         if propname in self._properties:
165             self._properties.remove(propname)
166             self._setting._set_properties(self._properties, self._opt)
167
168     def reset(self):
169         self._setting.reset(opt=self._opt)
170
171     def __contains__(self, propname):
172         return propname in self._properties
173
174     def __repr__(self):
175         return str(list(self._properties))
176
177
178 #____________________________________________________________
179 class Setting(object):
180     "``Config()``'s configuration options"
181     __slots__ = ('context', '_properties', '_permissives', '_owner', '_cache')
182
183     def __init__(self, context):
184         # properties attribute: the name of a property enables this property
185         # key is None for global properties
186         self._properties = {}
187         # permissive properties
188         self._permissives = {}
189         # generic owner
190         self._owner = owners.user
191         self.context = context
192         self._cache = {}
193
194     #____________________________________________________________
195     # properties methods
196     def __contains__(self, propname):
197         return propname in self._get_properties()
198
199     def __repr__(self):
200         return str(list(self._get_properties()))
201
202     def __getitem__(self, opt):
203         return Property(self, self._get_properties(opt), opt)
204
205     def __setitem__(self, opt, value):
206         raise ValueError('you must only append/remove properties')
207
208     def reset(self, opt=None, all_properties=False):
209         if all_properties and opt:
210             raise ValueError(_('opt and all_properties must not be set '
211                                'together in reset'))
212         if all_properties:
213             self._properties = {}
214         else:
215             try:
216                 del(self._properties[opt])
217             except KeyError:
218                 pass
219         self.context.cfgimpl_reset_cache()
220
221     def _get_properties(self, opt=None, is_apply_req=True):
222         if opt is None:
223             props = self._properties.get(opt, set(default_properties))
224         else:
225             exp = None
226             if opt in self._cache:
227                 exp = time()
228                 props, created = self._cache[opt]
229                 if exp < created:
230                     return props
231             if is_apply_req:
232                 self.apply_requires(opt)
233             props = self._properties.get(opt, set(opt._properties))
234             self._set_cache(opt, props, exp)
235         return props
236
237     def append(self, propname):
238         "puts property propname in the Config's properties attribute"
239         Property(self, self._get_properties()).append(propname)
240
241     def remove(self, propname):
242         "deletes property propname in the Config's properties attribute"
243         Property(self, self._get_properties()).remove(propname)
244
245     def _set_properties(self, properties, opt=None):
246         """save properties for specified opt
247         (never save properties if same has option properties)
248         """
249         if opt is None:
250             self._properties[opt] = properties
251         else:
252             if set(opt._properties) == properties:
253                 if opt in self._properties:
254                     del(self._properties[opt])
255             else:
256                 self._properties[opt] = properties
257         self.context.cfgimpl_reset_cache()
258
259     #____________________________________________________________
260     def validate_properties(self, opt_or_descr, is_descr, is_write,
261                             value=None, force_permissive=False,
262                             force_properties=None):
263         #opt properties
264         properties = copy(self._get_properties(opt_or_descr))
265         #remove opt permissive
266         properties -= self._get_permissive(opt_or_descr)
267         #remove global permissive if need
268         self_properties = copy(self._get_properties())
269         if force_permissive is True or 'permissive' in self_properties:
270             properties -= self._get_permissive()
271
272         #global properties
273         if force_properties is not None:
274             self_properties.update(force_properties)
275
276         #calc properties
277         properties &= self_properties
278         #mandatory and frozen are special properties
279         if is_descr:
280             properties -= frozenset(('mandatory', 'frozen'))
281         else:
282             if 'mandatory' in properties and \
283                     not self.context.cfgimpl_get_values()._is_empty(opt_or_descr,
284                                                                     value):
285                 properties.remove('mandatory')
286             if is_write and 'everything_frozen' in self_properties:
287                 properties.add('frozen')
288             elif 'frozen' in properties and not is_write:
289                 properties.remove('frozen')
290
291         if properties != frozenset():
292             comment = (opt_or_descr._name, str(list(properties)))
293             if 'frozen' in properties:
294                 raise PropertiesOptionError(_('cannot change the value for '
295                                               'option {0} this option is frozen'
296                                               '').format(comment))
297             else:
298                 raise PropertiesOptionError(_("trying to access to an option "
299                                               "named: {0} with properties {1}"
300                                               "").format(comment, list(properties)))
301
302     def _get_permissive(self, opt=None):
303         return self._permissives.get(opt, frozenset())
304
305     def set_permissive(self, permissive, opt=None):
306         if not isinstance(permissive, tuple):
307             raise TypeError(_('permissive must be a tuple'))
308         self._permissives[opt] = frozenset(permissive)
309
310     #____________________________________________________________
311     def setowner(self, owner):
312         ":param owner: sets the default value for owner at the Config level"
313         if not isinstance(owner, owners.Owner):
314             raise TypeError(_("invalid generic owner {0}").format(str(owner)))
315         self._owner = owner
316
317     def getowner(self):
318         return self._owner
319
320     #____________________________________________________________
321     def _read(self, remove, append):
322         for prop in remove:
323             self.remove(prop)
324         for prop in append:
325             self.append(prop)
326
327     def read_only(self):
328         "convenience method to freeze, hidde and disable"
329         self._read(ro_remove, ro_append)
330
331     def read_write(self):
332         "convenience method to freeze, hidde and disable"
333         self._read(rw_remove, rw_append)
334
335     def _set_cache(self, opt, props, exp):
336         if 'expire' in self:
337             if exp is None:
338                 exp = time()
339             self._cache[opt] = (props, time() + expires_time)
340
341     def reset_cache(self, only_expired):
342         if only_expired:
343             exp = time()
344             keys = self._cache.keys()
345             for key in keys:
346                 props, created = self._cache[key]
347                 if exp > created:
348                     del(self._cache[key])
349         else:
350             self._cache.clear()
351
352     def apply_requires(self, opt):
353         "carries out the jit (just in time requirements between options"
354         if opt._requires is None:
355             return
356
357         # filters the callbacks
358         setting = Property(self, self._get_properties(opt, False), opt)
359         descr = self.context.cfgimpl_get_description()
360         optpath = descr.impl_get_path_by_opt(opt)
361         for requires in opt._requires:
362             matches = False
363             for require in requires:
364                 option, expected, action, inverse, transitive, same_action = require
365                 path = descr.impl_get_path_by_opt(option)
366                 if path == optpath or path.startswith(optpath + '.'):
367                     raise RequirementError(_("malformed requirements "
368                                              "imbrication detected for option: '{0}' "
369                                              "with requirement on: '{1}'").format(optpath, path))
370                 try:
371                     value = self.context._getattr(path, force_permissive=True)
372                 except PropertiesOptionError, err:
373                     if not transitive:
374                         continue
375                     properties = err.proptype
376                     if same_action and action not in properties:
377                         raise RequirementError(_("option '{0}' has requirement's property error: "
378                                                  "{1} {2}").format(opt._name, path, properties))
379                     #transitive action, force expected
380                     value = expected[0]
381                     inverse = False
382                 except AttributeError:
383                     raise AttributeError(_("required option not found: "
384                                            "{0}").format(path))
385                 if not inverse and value in expected or inverse and value not in expected:
386                     matches = True
387                     setting.append(action)
388                     ## the calculation cannot be carried out
389                     break
390             # no requirement has been triggered, then just reverse the action
391             if not matches:
392                 setting.remove(action)