author | Sylvain Thénault <sylvain.thenault@logilab.fr> |
Thu, 30 Jul 2009 18:52:26 +0200 | |
changeset 2576 | 4ed80b85a22a |
parent 2476 | 1294a6bdf3bf |
child 2589 | 92f2bc945261 |
permissions | -rw-r--r-- |
0 | 1 |
""" |
2308
b478c3a8ad2a
typos, cleanup, lighter traced seletion output
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
2173
diff
changeset
|
2 |
* the vregistry handles various types of objects interacting |
b478c3a8ad2a
typos, cleanup, lighter traced seletion output
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
2173
diff
changeset
|
3 |
together. The vregistry handles registration of dynamically loaded |
b478c3a8ad2a
typos, cleanup, lighter traced seletion output
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
2173
diff
changeset
|
4 |
objects and provides a convenient api to access those objects |
0 | 5 |
according to a context |
6 |
||
2308
b478c3a8ad2a
typos, cleanup, lighter traced seletion output
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
2173
diff
changeset
|
7 |
* to interact with the vregistry, objects should inherit from the |
0 | 8 |
VObject abstract class |
1433 | 9 |
|
0 | 10 |
* the selection procedure has been generalized by delegating to a |
11 |
selector, which is responsible to score the vobject according to the |
|
12 |
current state (req, rset, row, col). At the end of the selection, if |
|
13 |
a vobject class has been found, an instance of this class is |
|
14 |
returned. The selector is instantiated at vobject registration |
|
15 |
||
16 |
||
17 |
:organization: Logilab |
|
1977
606923dff11b
big bunch of copyright / docstring update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1943
diff
changeset
|
18 |
:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2. |
0 | 19 |
:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr |
1977
606923dff11b
big bunch of copyright / docstring update
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
1943
diff
changeset
|
20 |
:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses |
0 | 21 |
""" |
22 |
__docformat__ = "restructuredtext en" |
|
23 |
||
24 |
import sys |
|
2083
f8f94c2951d3
add warning when rset isn't a named argument in select()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2058
diff
changeset
|
25 |
import types |
0 | 26 |
from os import listdir, stat |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
27 |
from os.path import dirname, join, realpath, split, isdir, exists |
0 | 28 |
from logging import getLogger |
2083
f8f94c2951d3
add warning when rset isn't a named argument in select()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2058
diff
changeset
|
29 |
from warnings import warn |
0 | 30 |
|
31 |
from cubicweb import CW_SOFTWARE_ROOT, set_log_methods |
|
32 |
from cubicweb import RegistryNotFound, ObjectNotFound, NoSelectableObject |
|
33 |
||
34 |
||
2025
010a4b0fe855
fix lookup of files to load when using CW_CUBES_PATH
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
35 |
def _toload_info(path, extrapath, _toload=None): |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
36 |
"""return a dictionary of <modname>: <modpath> and an ordered list of |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
37 |
(file, module name) to load |
0 | 38 |
""" |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
39 |
from logilab.common.modutils import modpath_from_file |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
40 |
if _toload is None: |
2025
010a4b0fe855
fix lookup of files to load when using CW_CUBES_PATH
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
41 |
assert isinstance(path, list) |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
42 |
_toload = {}, [] |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
43 |
for fileordir in path: |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
44 |
if isdir(fileordir) and exists(join(fileordir, '__init__.py')): |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
45 |
subfiles = [join(fileordir, fname) for fname in listdir(fileordir)] |
2025
010a4b0fe855
fix lookup of files to load when using CW_CUBES_PATH
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
46 |
_toload_info(subfiles, extrapath, _toload) |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
47 |
elif fileordir[-3:] == '.py': |
2025
010a4b0fe855
fix lookup of files to load when using CW_CUBES_PATH
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
48 |
modname = '.'.join(modpath_from_file(fileordir, extrapath)) |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
49 |
_toload[0][modname] = fileordir |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
50 |
_toload[1].append((fileordir, modname)) |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
51 |
return _toload |
0 | 52 |
|
53 |
||
54 |
class VObject(object): |
|
55 |
"""visual object, use to be handled somehow by the visual components |
|
56 |
registry. |
|
57 |
||
58 |
The following attributes should be set on concret vobject subclasses: |
|
1433 | 59 |
|
0 | 60 |
:__registry__: |
61 |
name of the registry for this object (string like 'views', |
|
62 |
'templates'...) |
|
63 |
:id: |
|
64 |
object's identifier in the registry (string like 'main', |
|
65 |
'primary', 'folder_box') |
|
66 |
:__select__: |
|
719 | 67 |
class'selector |
1433 | 68 |
|
0 | 69 |
Moreover, the `__abstract__` attribute may be set to True to indicate |
70 |
that a vobject is abstract and should not be registered |
|
71 |
""" |
|
72 |
# necessary attributes to interact with the registry |
|
73 |
id = None |
|
74 |
__registry__ = None |
|
75 |
__select__ = None |
|
76 |
||
77 |
@classmethod |
|
78 |
def registered(cls, registry): |
|
79 |
"""called by the registry when the vobject has been registered. |
|
80 |
||
81 |
It must return the object that will be actually registered (this |
|
82 |
may be the right hook to create an instance for example). By |
|
83 |
default the vobject is returned without any transformation. |
|
84 |
""" |
|
741 | 85 |
cls.build___select__() |
0 | 86 |
return cls |
87 |
||
88 |
@classmethod |
|
89 |
def selected(cls, *args, **kwargs): |
|
90 |
"""called by the registry when the vobject has been selected. |
|
1433 | 91 |
|
0 | 92 |
It must return the object that will be actually returned by the |
93 |
.select method (this may be the right hook to create an |
|
94 |
instance for example). By default the selected object is |
|
95 |
returned without any transformation. |
|
96 |
""" |
|
97 |
return cls |
|
98 |
||
99 |
@classmethod |
|
100 |
def classid(cls): |
|
101 |
"""returns a unique identifier for the vobject""" |
|
102 |
return '%s.%s' % (cls.__module__, cls.__name__) |
|
103 |
||
736
18c940e3f98d
need safety belt for class registered twice (during test for instance)
sylvain.thenault@logilab.fr
parents:
735
diff
changeset
|
104 |
# XXX bw compat code |
712
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
105 |
@classmethod |
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
106 |
def build___select__(cls): |
943
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
107 |
for klass in cls.mro(): |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
108 |
if klass.__name__ == 'AppRsetObject': |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
109 |
continue # the bw compat __selector__ is there |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
110 |
klassdict = klass.__dict__ |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
111 |
if ('__select__' in klassdict and '__selectors__' in klassdict |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
112 |
and '__selgenerated__' not in klassdict): |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
113 |
raise TypeError("__select__ and __selectors__ can't be used together on class %s" % cls) |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
114 |
if '__selectors__' in klassdict and '__selgenerated__' not in klassdict: |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
115 |
cls.__selgenerated__ = True |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
116 |
# case where __selectors__ is defined locally (but __select__ |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
117 |
# is in a parent class) |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
118 |
selectors = klassdict['__selectors__'] |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
119 |
if len(selectors) == 1: |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
120 |
# micro optimization: don't bother with AndSelector if there's |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
121 |
# only one selector |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
122 |
select = _instantiate_selector(selectors[0]) |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
123 |
else: |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
124 |
select = AndSelector(*selectors) |
9fdfa8d38359
[selectors] for bacwkard compatibility, we must search the mro, not just the current class, in order not to miss __selectors__ in classes that do not redefine it
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
835
diff
changeset
|
125 |
cls.__select__ = select |
712
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
126 |
|
0 | 127 |
|
128 |
class VRegistry(object): |
|
129 |
"""class responsible to register, propose and select the various |
|
130 |
elements used to build the web interface. Currently, we have templates, |
|
131 |
views, actions and components. |
|
132 |
""" |
|
1433 | 133 |
|
0 | 134 |
def __init__(self, config):#, cache_size=1000): |
135 |
self.config = config |
|
136 |
# dictionnary of registry (themself dictionnary) by name |
|
137 |
self._registries = {} |
|
138 |
self._lastmodifs = {} |
|
139 |
||
140 |
def reset(self): |
|
141 |
self._registries = {} |
|
142 |
self._lastmodifs = {} |
|
143 |
||
144 |
def __getitem__(self, key): |
|
145 |
return self._registries[key] |
|
146 |
||
147 |
def get(self, key, default=None): |
|
148 |
return self._registries.get(key, default) |
|
149 |
||
150 |
def items(self): |
|
151 |
return self._registries.items() |
|
152 |
||
153 |
def values(self): |
|
154 |
return self._registries.values() |
|
155 |
||
156 |
def __contains__(self, key): |
|
157 |
return key in self._registries |
|
660
5233a9457f6b
work in progress, draft for manual registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
652
diff
changeset
|
158 |
|
0 | 159 |
def registry(self, name): |
160 |
"""return the registry (dictionary of class objects) associated to |
|
161 |
this name |
|
162 |
""" |
|
163 |
try: |
|
164 |
return self._registries[name] |
|
165 |
except KeyError: |
|
166 |
raise RegistryNotFound(name), None, sys.exc_info()[-1] |
|
167 |
||
168 |
def registry_objects(self, name, oid=None): |
|
169 |
"""returns objects registered with the given oid in the given registry. |
|
170 |
If no oid is given, return all objects in this registry |
|
171 |
""" |
|
172 |
registry = self.registry(name) |
|
2058
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
173 |
if oid is not None: |
0 | 174 |
try: |
175 |
return registry[oid] |
|
176 |
except KeyError: |
|
177 |
raise ObjectNotFound(oid), None, sys.exc_info()[-1] |
|
2058
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
178 |
result = [] |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
179 |
for objs in registry.values(): |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
180 |
result += objs |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
181 |
return result |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
182 |
|
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
183 |
# dynamic selection methods ################################################ |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
184 |
|
2058
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
185 |
def object_by_id(self, registry, oid, *args, **kwargs): |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
186 |
"""return object in <registry>.<oid> |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
187 |
|
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
188 |
raise `ObjectNotFound` if not object with id <oid> in <registry> |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
189 |
raise `AssertionError` if there is more than one object there |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
190 |
""" |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
191 |
objects = self.registry_objects(registry, oid) |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
192 |
assert len(objects) == 1, objects |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
193 |
return objects[0].selected(*args, **kwargs) |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
194 |
|
2058
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
195 |
def select(self, registry, oid, *args, **kwargs): |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
196 |
"""return the most specific object in <registry>.<oid> according to |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
197 |
the given context |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
198 |
|
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
199 |
raise `ObjectNotFound` if not object with id <oid> in <registry> |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
200 |
raise `NoSelectableObject` if not object apply |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
201 |
""" |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
202 |
return self.select_best(self.registry_objects(registry, oid), |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
203 |
*args, **kwargs) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
204 |
|
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
205 |
def select_object(self, registry, oid, *args, **kwargs): |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
206 |
"""return the most specific object in <registry>.<oid> according to |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
207 |
the given context, or None if no object apply |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
208 |
""" |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
209 |
try: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
210 |
return self.select(registry, oid, *args, **kwargs) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
211 |
except (NoSelectableObject, ObjectNotFound): |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
212 |
return None |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
213 |
|
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
214 |
def possible_objects(self, registry, *args, **kwargs): |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
215 |
"""return an iterator on possible objects in <registry> for the given |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
216 |
context |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
217 |
""" |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
218 |
for vobjects in self.registry(registry).itervalues(): |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
219 |
try: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
220 |
yield self.select_best(vobjects, *args, **kwargs) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
221 |
except NoSelectableObject: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
222 |
continue |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
223 |
|
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
224 |
def select_best(self, vobjects, *args, **kwargs): |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
225 |
"""return an instance of the most specific object according |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
226 |
to parameters |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
227 |
|
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
228 |
raise `NoSelectableObject` if not object apply |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
229 |
""" |
2083
f8f94c2951d3
add warning when rset isn't a named argument in select()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2058
diff
changeset
|
230 |
if len(args) > 1: |
f8f94c2951d3
add warning when rset isn't a named argument in select()
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2058
diff
changeset
|
231 |
warn('only the request param can not be named when calling select', |
2302
e0393451e9a5
fix stacklevel
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2181
diff
changeset
|
232 |
DeprecationWarning, stacklevel=3) |
2058
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
233 |
score, winners = 0, [] |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
234 |
for vobject in vobjects: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
235 |
vobjectscore = vobject.__select__(vobject, *args, **kwargs) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
236 |
if vobjectscore > score: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
237 |
score, winners = vobjectscore, [vobject] |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
238 |
elif vobjectscore > 0 and vobjectscore == score: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
239 |
winners.append(vobject) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
240 |
if not winners: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
241 |
raise NoSelectableObject('args: %s\nkwargs: %s %s' |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
242 |
% (args, kwargs.keys(), |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
243 |
[repr(v) for v in vobjects])) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
244 |
if len(winners) > 1: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
245 |
if self.config.mode == 'installed': |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
246 |
self.error('select ambiguity, args: %s\nkwargs: %s %s', |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
247 |
args, kwargs.keys(), [repr(v) for v in winners]) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
248 |
else: |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
249 |
raise Exception('select ambiguity, args: %s\nkwargs: %s %s' |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
250 |
% (args, kwargs.keys(), |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
251 |
[repr(v) for v in winners])) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
252 |
# return the result of the .selected method of the vobject |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
253 |
return winners[0].selected(*args, **kwargs) |
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
254 |
|
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
255 |
# methods for explicit (un)registration ################################### |
668
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
256 |
|
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
257 |
# def clear(self, key): |
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
258 |
# regname, oid = key.split('.') |
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
259 |
# self[regname].pop(oid, None) |
2058
7ef12c03447c
nicer vreg api, try to make rset an optional named argument in select and derivated (including selectors)
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
260 |
|
695 | 261 |
def register_all(self, objects, modname, butclasses=()): |
262 |
for obj in objects: |
|
263 |
try: |
|
264 |
if obj.__module__ != modname or obj in butclasses: |
|
265 |
continue |
|
266 |
oid = obj.id |
|
267 |
except AttributeError: |
|
268 |
continue |
|
269 |
if oid: |
|
270 |
self.register(obj) |
|
1433 | 271 |
|
668
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
272 |
def register(self, obj, registryname=None, oid=None, clear=False): |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
273 |
"""base method to add an object in the registry""" |
707 | 274 |
assert not '__abstract__' in obj.__dict__ |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
275 |
registryname = registryname or obj.__registry__ |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
276 |
oid = oid or obj.id |
739 | 277 |
assert oid |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
278 |
registry = self._registries.setdefault(registryname, {}) |
668
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
279 |
if clear: |
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
280 |
vobjects = registry[oid] = [] |
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
281 |
else: |
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
282 |
vobjects = registry.setdefault(oid, []) |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
283 |
# registered() is technically a classmethod but is not declared |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
284 |
# as such because we need to compose registered in some cases |
682 | 285 |
vobject = obj.registered.im_func(obj, self) |
2078
362703bff3d4
typo: fix assertion error message in vregistry.py
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
2077
diff
changeset
|
286 |
assert not vobject in vobjects, \ |
2077
50beca829273
nicer message on failure
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2065
diff
changeset
|
287 |
'object %s is already registered' % vobject |
804 | 288 |
assert callable(vobject.__select__), vobject |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
289 |
vobjects.append(vobject) |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
290 |
try: |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
291 |
vname = vobject.__name__ |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
292 |
except AttributeError: |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
293 |
vname = vobject.__class__.__name__ |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
294 |
self.debug('registered vobject %s in registry %s with id %s', |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
295 |
vname, registryname, oid) |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
296 |
# automatic reloading management |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
297 |
self._loadedmods[obj.__module__]['%s.%s' % (obj.__module__, oid)] = obj |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
298 |
|
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
299 |
def unregister(self, obj, registryname=None): |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
300 |
registryname = registryname or obj.__registry__ |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
301 |
registry = self.registry(registryname) |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
302 |
removed_id = obj.classid() |
2065
f9f4bc048ec5
fix unregister to be more error resilient as other unregistering methods + cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
303 |
for registered in registry.get(obj.id, ()): |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
304 |
# use classid() to compare classes because vreg will probably |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
305 |
# have its own version of the class, loaded through execfile |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
306 |
if registered.classid() == removed_id: |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
307 |
# XXX automatic reloading management |
2065
f9f4bc048ec5
fix unregister to be more error resilient as other unregistering methods + cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
308 |
registry[obj.id].remove(registered) |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
309 |
break |
2065
f9f4bc048ec5
fix unregister to be more error resilient as other unregistering methods + cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
310 |
else: |
f9f4bc048ec5
fix unregister to be more error resilient as other unregistering methods + cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
311 |
self.warning('can\'t remove %s, no id %s in the %s registry', |
f9f4bc048ec5
fix unregister to be more error resilient as other unregistering methods + cleanup
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2035
diff
changeset
|
312 |
removed_id, obj.id, registryname) |
1433 | 313 |
|
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
314 |
def register_and_replace(self, obj, replaced, registryname=None): |
2173
7fae9300b9f9
[doc] improvements
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
2078
diff
changeset
|
315 |
# XXXFIXME this is a duplication of unregister() |
7fae9300b9f9
[doc] improvements
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
2078
diff
changeset
|
316 |
# remove register_and_replace in favor of unregister + register |
7fae9300b9f9
[doc] improvements
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
2078
diff
changeset
|
317 |
# or simplify by calling unregister then register here |
673 | 318 |
if hasattr(replaced, 'classid'): |
319 |
replaced = replaced.classid() |
|
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
320 |
registryname = registryname or obj.__registry__ |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
321 |
registry = self.registry(registryname) |
1943
fb557b616c80
fix exception class, simply print warning when calling register_and_replace with an unregistered view
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1641
diff
changeset
|
322 |
registered_objs = registry.get(obj.id, ()) |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
323 |
for index, registered in enumerate(registered_objs): |
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
324 |
if registered.classid() == replaced: |
673 | 325 |
del registry[obj.id][index] |
326 |
break |
|
1943
fb557b616c80
fix exception class, simply print warning when calling register_and_replace with an unregistered view
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1641
diff
changeset
|
327 |
else: |
fb557b616c80
fix exception class, simply print warning when calling register_and_replace with an unregistered view
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1641
diff
changeset
|
328 |
self.warning('trying to replace an unregistered view %s by %s', |
fb557b616c80
fix exception class, simply print warning when calling register_and_replace with an unregistered view
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1641
diff
changeset
|
329 |
replaced, obj) |
673 | 330 |
self.register(obj, registryname=registryname) |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
331 |
|
0 | 332 |
# intialization methods ################################################### |
1433 | 333 |
|
2035
946ed7349e1a
bugfix: extrapath is optional arg for init_registration
Nicolas Chauvat <nicolas.chauvat@logilab.fr>
parents:
2025
diff
changeset
|
334 |
def init_registration(self, path, extrapath=None): |
1316
6d71d38822ee
introduce init_registration method and call it in repo initialization
sylvain.thenault@logilab.fr
parents:
1310
diff
changeset
|
335 |
# compute list of all modules that have to be loaded |
2025
010a4b0fe855
fix lookup of files to load when using CW_CUBES_PATH
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
336 |
self._toloadmods, filemods = _toload_info(path, extrapath) |
1316
6d71d38822ee
introduce init_registration method and call it in repo initialization
sylvain.thenault@logilab.fr
parents:
1310
diff
changeset
|
337 |
self._loadedmods = {} |
6d71d38822ee
introduce init_registration method and call it in repo initialization
sylvain.thenault@logilab.fr
parents:
1310
diff
changeset
|
338 |
return filemods |
1433 | 339 |
|
2025
010a4b0fe855
fix lookup of files to load when using CW_CUBES_PATH
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
340 |
def register_objects(self, path, force_reload=None, extrapath=None): |
0 | 341 |
if force_reload is None: |
342 |
force_reload = self.config.mode == 'dev' |
|
343 |
elif not force_reload: |
|
344 |
# force_reload == False usually mean modules have been reloaded |
|
345 |
# by another connection, so we want to update the registry |
|
346 |
# content even if there has been no module content modification |
|
347 |
self.reset() |
|
348 |
# need to clean sys.path this to avoid import confusion pb (i.e. |
|
349 |
# having the same module loaded as 'cubicweb.web.views' subpackage and |
|
350 |
# as views' or 'web.views' subpackage |
|
351 |
# this is mainly for testing purpose, we should'nt need this in |
|
352 |
# production environment |
|
353 |
for webdir in (join(dirname(realpath(__file__)), 'web'), |
|
354 |
join(dirname(__file__), 'web')): |
|
355 |
if webdir in sys.path: |
|
356 |
sys.path.remove(webdir) |
|
357 |
if CW_SOFTWARE_ROOT in sys.path: |
|
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
358 |
sys.path.remove(CW_SOFTWARE_ROOT) |
2476
1294a6bdf3bf
application -> instance where it makes sense
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
2381
diff
changeset
|
359 |
# load views from each directory in the instance's path |
2025
010a4b0fe855
fix lookup of files to load when using CW_CUBES_PATH
Sylvain Thénault <sylvain.thenault@logilab.fr>
parents:
1977
diff
changeset
|
360 |
filemods = self.init_registration(path, extrapath) |
0 | 361 |
change = False |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
362 |
for filepath, modname in filemods: |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
363 |
if self.load_file(filepath, modname, force_reload): |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
364 |
change = True |
0 | 365 |
return change |
1433 | 366 |
|
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
367 |
def load_file(self, filepath, modname, force_reload=False): |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
368 |
"""load visual objects from a python file""" |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
369 |
from logilab.common.modutils import load_module_from_name |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
370 |
if modname in self._loadedmods: |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
371 |
return |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
372 |
self._loadedmods[modname] = {} |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
373 |
try: |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
374 |
modified_on = stat(filepath)[-2] |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
375 |
except OSError: |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
376 |
# this typically happens on emacs backup files (.#foo.py) |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
377 |
self.warning('Unable to load %s. It is likely to be a backup file', |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
378 |
filepath) |
0 | 379 |
return False |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
380 |
if filepath in self._lastmodifs: |
0 | 381 |
# only load file if it was modified |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
382 |
if modified_on <= self._lastmodifs[filepath]: |
0 | 383 |
return |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
384 |
# if it was modified, unregister all exisiting objects |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
385 |
# from this module, and keep track of what was unregistered |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
386 |
unregistered = self.unregister_module_vobjects(modname) |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
387 |
else: |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
388 |
unregistered = None |
0 | 389 |
# load the module |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
390 |
module = load_module_from_name(modname, use_sys=not force_reload) |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
391 |
self.load_module(module) |
0 | 392 |
# if something was unregistered, we need to update places where it was |
1433 | 393 |
# referenced |
0 | 394 |
if unregistered: |
395 |
# oldnew_mapping = {} |
|
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
396 |
registered = self._loadedmods[modname] |
0 | 397 |
oldnew_mapping = dict((unregistered[name], registered[name]) |
398 |
for name in unregistered if name in registered) |
|
399 |
self.update_registered_subclasses(oldnew_mapping) |
|
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
400 |
self._lastmodifs[filepath] = modified_on |
0 | 401 |
return True |
402 |
||
403 |
def load_module(self, module): |
|
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
404 |
self.info('loading %s', module) |
668
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
405 |
if hasattr(module, 'registration_callback'): |
61b2328f9ed9
rename registration callback, clear argument to register
sylvain.thenault@logilab.fr
parents:
665
diff
changeset
|
406 |
module.registration_callback(self) |
660
5233a9457f6b
work in progress, draft for manual registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
652
diff
changeset
|
407 |
else: |
5233a9457f6b
work in progress, draft for manual registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
652
diff
changeset
|
408 |
for objname, obj in vars(module).items(): |
5233a9457f6b
work in progress, draft for manual registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
652
diff
changeset
|
409 |
if objname.startswith('_'): |
5233a9457f6b
work in progress, draft for manual registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
652
diff
changeset
|
410 |
continue |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
411 |
self._load_ancestors_then_object(module.__name__, obj) |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
412 |
self.debug('loaded %s', module) |
1433 | 413 |
|
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
414 |
def _load_ancestors_then_object(self, modname, obj): |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
415 |
# imported classes |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
416 |
objmodname = getattr(obj, '__module__', None) |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
417 |
if objmodname != modname: |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
418 |
if objmodname in self._toloadmods: |
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
419 |
self.load_file(self._toloadmods[objmodname], objmodname) |
0 | 420 |
return |
421 |
# skip non registerable object |
|
422 |
try: |
|
423 |
if not issubclass(obj, VObject): |
|
424 |
return |
|
425 |
except TypeError: |
|
426 |
return |
|
427 |
objname = '%s.%s' % (modname, obj.__name__) |
|
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
428 |
if objname in self._loadedmods[modname]: |
0 | 429 |
return |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
430 |
self._loadedmods[modname][objname] = obj |
0 | 431 |
for parent in obj.__bases__: |
1310
99dfced5673e
fix vobjects registration to deal with objects inter-dependancy
sylvain.thenault@logilab.fr
parents:
1282
diff
changeset
|
432 |
self._load_ancestors_then_object(modname, parent) |
0 | 433 |
self.load_object(obj) |
1433 | 434 |
|
0 | 435 |
def load_object(self, obj): |
436 |
try: |
|
437 |
self.register_vobject_class(obj) |
|
438 |
except Exception, ex: |
|
439 |
if self.config.mode in ('test', 'dev'): |
|
440 |
raise |
|
441 |
self.exception('vobject %s registration failed: %s', obj, ex) |
|
1433 | 442 |
|
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
443 |
# old automatic registration XXX deprecated ############################### |
1433 | 444 |
|
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
445 |
def register_vobject_class(self, cls): |
0 | 446 |
"""handle vobject class registration |
1433 | 447 |
|
0 | 448 |
vobject class with __abstract__ == True in their local dictionnary or |
449 |
with a name starting starting by an underscore are not registered. |
|
450 |
Also a vobject class needs to have __registry__ and id attributes set |
|
451 |
to a non empty string to be registered. |
|
452 |
""" |
|
453 |
if (cls.__dict__.get('__abstract__') or cls.__name__[0] == '_' |
|
454 |
or not cls.__registry__ or not cls.id): |
|
455 |
return |
|
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
456 |
regname = cls.__registry__ |
1046
52ee022d87e3
simplify registry options to disable some appobjects to use a single option
sylvain.thenault@logilab.fr
parents:
946
diff
changeset
|
457 |
if '%s.%s' % (regname, cls.id) in self.config['disable-appobjects']: |
665
1305da1ce3f9
reorganize a bit, some cleanup and fixes
sylvain.thenault@logilab.fr
parents:
660
diff
changeset
|
458 |
return |
1432
2c3711d4570b
drop hopeless registerer bw compat
sylvain.thenault@logilab.fr
parents:
1316
diff
changeset
|
459 |
self.register(cls) |
1433 | 460 |
|
0 | 461 |
def unregister_module_vobjects(self, modname): |
462 |
"""removes registered objects coming from a given module |
|
463 |
||
464 |
returns a dictionnary classid/class of all classes that will need |
|
465 |
to be updated after reload (i.e. vobjects referencing classes defined |
|
466 |
in the <modname> module) |
|
467 |
""" |
|
468 |
unregistered = {} |
|
469 |
# browse each registered object |
|
470 |
for registry, objdict in self.items(): |
|
471 |
for oid, objects in objdict.items(): |
|
472 |
for obj in objects[:]: |
|
473 |
objname = obj.classid() |
|
474 |
# if the vobject is defined in this module, remove it |
|
475 |
if objname.startswith(modname): |
|
476 |
unregistered[objname] = obj |
|
477 |
objects.remove(obj) |
|
478 |
self.debug('unregistering %s in %s registry', |
|
479 |
objname, registry) |
|
480 |
# if not, check if the vobject can be found in baseclasses |
|
481 |
# (because we also want subclasses to be updated) |
|
482 |
else: |
|
483 |
if not isinstance(obj, type): |
|
484 |
obj = obj.__class__ |
|
485 |
for baseclass in obj.__bases__: |
|
486 |
if hasattr(baseclass, 'classid'): |
|
487 |
baseclassid = baseclass.classid() |
|
488 |
if baseclassid.startswith(modname): |
|
489 |
unregistered[baseclassid] = baseclass |
|
490 |
# update oid entry |
|
491 |
if objects: |
|
492 |
objdict[oid] = objects |
|
493 |
else: |
|
494 |
del objdict[oid] |
|
495 |
return unregistered |
|
496 |
||
497 |
def update_registered_subclasses(self, oldnew_mapping): |
|
498 |
"""updates subclasses of re-registered vobjects |
|
499 |
||
500 |
if baseviews.PrimaryView is changed, baseviews.py will be reloaded |
|
501 |
automatically and the new version of PrimaryView will be registered. |
|
502 |
But all existing subclasses must also be notified of this change, and |
|
503 |
that's what this method does |
|
504 |
||
505 |
:param oldnew_mapping: a dict mapping old version of a class to |
|
506 |
the new version |
|
507 |
""" |
|
508 |
# browse each registered object |
|
509 |
for objdict in self.values(): |
|
510 |
for objects in objdict.values(): |
|
511 |
for obj in objects: |
|
512 |
if not isinstance(obj, type): |
|
513 |
obj = obj.__class__ |
|
514 |
# build new baseclasses tuple |
|
515 |
newbases = tuple(oldnew_mapping.get(baseclass, baseclass) |
|
516 |
for baseclass in obj.__bases__) |
|
517 |
# update obj's baseclasses tuple (__bases__) if needed |
|
518 |
if newbases != obj.__bases__: |
|
519 |
self.debug('updating %s.%s base classes', |
|
520 |
obj.__module__, obj.__name__) |
|
521 |
obj.__bases__ = newbases |
|
522 |
||
1433 | 523 |
# init logging |
0 | 524 |
set_log_methods(VObject, getLogger('cubicweb')) |
525 |
set_log_methods(VRegistry, getLogger('cubicweb.registry')) |
|
526 |
||
527 |
||
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
528 |
# selector base classes and operations ######################################## |
631
99f5852f8604
major selector refactoring (mostly to avoid looking for select parameters on the target class), start accept / interface unification)
sylvain.thenault@logilab.fr
parents:
630
diff
changeset
|
529 |
|
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
530 |
class Selector(object): |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
531 |
"""base class for selector classes providing implementation |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
532 |
for operators ``&`` and ``|`` |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
533 |
|
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
534 |
This class is only here to give access to binary operators, the |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
535 |
selector logic itself should be implemented in the __call__ method |
0 | 536 |
|
537 |
||
718
f7011679437a
doc update, move yes_registerer here
sylvain.thenault@logilab.fr
parents:
714
diff
changeset
|
538 |
a selector is called to help choosing the correct object for a |
f7011679437a
doc update, move yes_registerer here
sylvain.thenault@logilab.fr
parents:
714
diff
changeset
|
539 |
particular context by returning a score (`int`) telling how well |
f7011679437a
doc update, move yes_registerer here
sylvain.thenault@logilab.fr
parents:
714
diff
changeset
|
540 |
the class given as first argument apply to the given context. |
f7011679437a
doc update, move yes_registerer here
sylvain.thenault@logilab.fr
parents:
714
diff
changeset
|
541 |
|
f7011679437a
doc update, move yes_registerer here
sylvain.thenault@logilab.fr
parents:
714
diff
changeset
|
542 |
0 score means that the class doesn't apply. |
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
543 |
""" |
698
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
544 |
|
711
f758b86cf484
Selector objects need to provide a `func_name` attribute for minimum (backward)
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
710
diff
changeset
|
545 |
@property |
f758b86cf484
Selector objects need to provide a `func_name` attribute for minimum (backward)
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
710
diff
changeset
|
546 |
def func_name(self): |
f758b86cf484
Selector objects need to provide a `func_name` attribute for minimum (backward)
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
710
diff
changeset
|
547 |
# backward compatibility |
f758b86cf484
Selector objects need to provide a `func_name` attribute for minimum (backward)
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
710
diff
changeset
|
548 |
return self.__class__.__name__ |
f758b86cf484
Selector objects need to provide a `func_name` attribute for minimum (backward)
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
710
diff
changeset
|
549 |
|
698
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
550 |
def search_selector(self, selector): |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
551 |
"""search for the given selector or selector instance in the selectors |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
552 |
tree. Return it of None if not found |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
553 |
""" |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
554 |
if self is selector: |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
555 |
return self |
721 | 556 |
if isinstance(selector, type) and isinstance(self, selector): |
698
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
557 |
return self |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
558 |
return None |
780
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
559 |
|
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
560 |
def __str__(self): |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
561 |
return self.__class__.__name__ |
1433 | 562 |
|
698
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
563 |
def __and__(self, other): |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
564 |
return AndSelector(self, other) |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
565 |
def __rand__(self, other): |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
566 |
return AndSelector(other, self) |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
567 |
|
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
568 |
def __or__(self, other): |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
569 |
return OrSelector(self, other) |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
570 |
def __ror__(self, other): |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
571 |
return OrSelector(other, self) |
827
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
572 |
|
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
573 |
def __invert__(self): |
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
574 |
return NotSelector(self) |
1433 | 575 |
|
698
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
576 |
# XXX (function | function) or (function & function) not managed yet |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
577 |
|
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
578 |
def __call__(self, cls, *args, **kwargs): |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
579 |
return NotImplementedError("selector %s must implement its logic " |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
580 |
"in its __call__ method" % self.__class__) |
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
581 |
|
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
582 |
class MultiSelector(Selector): |
718
f7011679437a
doc update, move yes_registerer here
sylvain.thenault@logilab.fr
parents:
714
diff
changeset
|
583 |
"""base class for compound selector classes""" |
1433 | 584 |
|
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
585 |
def __init__(self, *selectors): |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
586 |
self.selectors = self.merge_selectors(selectors) |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
587 |
|
780
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
588 |
def __str__(self): |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
589 |
return '%s(%s)' % (self.__class__.__name__, |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
590 |
','.join(str(s) for s in self.selectors)) |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
591 |
|
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
592 |
@classmethod |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
593 |
def merge_selectors(cls, selectors): |
780
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
594 |
"""deal with selector instanciation when necessary and merge |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
595 |
multi-selectors if possible: |
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
596 |
|
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
597 |
AndSelector(AndSelector(sel1, sel2), AndSelector(sel3, sel4)) |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
598 |
==> AndSelector(sel1, sel2, sel3, sel4) |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
599 |
""" |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
600 |
merged_selectors = [] |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
601 |
for selector in selectors: |
946
a130b5ceeca9
[selectors] _needs real fix_ whack 'till it works for me
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
943
diff
changeset
|
602 |
try: |
a130b5ceeca9
[selectors] _needs real fix_ whack 'till it works for me
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
943
diff
changeset
|
603 |
selector = _instantiate_selector(selector) |
a130b5ceeca9
[selectors] _needs real fix_ whack 'till it works for me
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
943
diff
changeset
|
604 |
except: |
a130b5ceeca9
[selectors] _needs real fix_ whack 'till it works for me
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
943
diff
changeset
|
605 |
pass |
a130b5ceeca9
[selectors] _needs real fix_ whack 'till it works for me
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
943
diff
changeset
|
606 |
#assert isinstance(selector, Selector), selector |
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
607 |
if isinstance(selector, cls): |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
608 |
merged_selectors += selector.selectors |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
609 |
else: |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
610 |
merged_selectors.append(selector) |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
611 |
return merged_selectors |
0 | 612 |
|
693
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
613 |
def search_selector(self, selector): |
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
614 |
"""search for the given selector or selector instance in the selectors |
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
615 |
tree. Return it of None if not found |
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
616 |
""" |
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
617 |
for childselector in self.selectors: |
780
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
618 |
if childselector is selector: |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
619 |
return childselector |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
620 |
found = childselector.search_selector(selector) |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
621 |
if found is not None: |
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
622 |
return found |
693
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
623 |
return None |
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
624 |
|
1433 | 625 |
|
697
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
626 |
def objectify_selector(selector_func): |
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
627 |
"""convenience decorator for simple selectors where a class definition |
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
628 |
would be overkill:: |
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
629 |
|
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
630 |
@objectify_selector |
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
631 |
def yes(cls, *args, **kwargs): |
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
632 |
return 1 |
1433 | 633 |
|
697
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
634 |
""" |
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
635 |
return type(selector_func.__name__, (Selector,), |
734 | 636 |
{'__call__': lambda self, *args, **kwargs: selector_func(*args, **kwargs)}) |
697
06807984e610
provide objectify_selector decorator for very simple selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
695
diff
changeset
|
637 |
|
712
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
638 |
def _instantiate_selector(selector): |
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
639 |
"""ensures `selector` is a `Selector` instance |
1433 | 640 |
|
712
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
641 |
NOTE: This should only be used locally in build___select__() |
946
a130b5ceeca9
[selectors] _needs real fix_ whack 'till it works for me
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
943
diff
changeset
|
642 |
XXX: then, why not do it ?? |
712
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
643 |
""" |
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
644 |
if isinstance(selector, types.FunctionType): |
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
645 |
return objectify_selector(selector)() |
727
30fe8f5afbd8
fix _instantiate_selector() mini bug (make sure obj is a class before calling issubclass)
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
724
diff
changeset
|
646 |
if isinstance(selector, type) and issubclass(selector, Selector): |
712
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
647 |
return selector() |
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
648 |
return selector |
ce49e3885453
remove autoselectors metaclass, __select__ is built during registration
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
711
diff
changeset
|
649 |
|
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
650 |
|
698
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
651 |
class AndSelector(MultiSelector): |
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
652 |
"""and-chained selectors (formerly known as chainall)""" |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
653 |
def __call__(self, cls, *args, **kwargs): |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
654 |
score = 0 |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
655 |
for selector in self.selectors: |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
656 |
partscore = selector(cls, *args, **kwargs) |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
657 |
if not partscore: |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
658 |
return 0 |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
659 |
score += partscore |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
660 |
return score |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
661 |
|
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
662 |
|
698
7dfd03e9e810
introduce MultiSelector base class
sylvain.thenault@logilab.fr
parents:
697
diff
changeset
|
663 |
class OrSelector(MultiSelector): |
630
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
664 |
"""or-chained selectors (formerly known as chainfirst)""" |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
665 |
def __call__(self, cls, *args, **kwargs): |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
666 |
for selector in self.selectors: |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
667 |
partscore = selector(cls, *args, **kwargs) |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
668 |
if partscore: |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
669 |
return partscore |
66ff0b2f7d03
simple test implementation for binary operators on selectors
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
615
diff
changeset
|
670 |
return 0 |
693
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
671 |
|
827
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
672 |
class NotSelector(Selector): |
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
673 |
"""negation selector""" |
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
674 |
def __init__(self, selector): |
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
675 |
self.selector = selector |
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
676 |
|
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
677 |
def __call__(self, cls, *args, **kwargs): |
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
678 |
score = self.selector(cls, *args, **kwargs) |
835
7dcb11dd443e
fix relation_possible, ensure we return int
sylvain.thenault@logilab.fr
parents:
827
diff
changeset
|
679 |
return int(not score) |
827
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
680 |
|
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
681 |
def __str__(self): |
3f08481e6e51
provide negation operator for selectors, unfortunately, it's not possible to user the python keyword 'not'
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
804
diff
changeset
|
682 |
return 'NOT(%s)' % super(NotSelector, self).__str__() |
693
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
683 |
|
835
7dcb11dd443e
fix relation_possible, ensure we return int
sylvain.thenault@logilab.fr
parents:
827
diff
changeset
|
684 |
|
7dcb11dd443e
fix relation_possible, ensure we return int
sylvain.thenault@logilab.fr
parents:
827
diff
changeset
|
685 |
# XXX bw compat functions ##################################################### |
693
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
686 |
|
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
687 |
def chainall(*selectors, **kwargs): |
0 | 688 |
"""return a selector chaining given selectors. If one of |
689 |
the selectors fail, selection will fail, else the returned score |
|
690 |
will be the sum of each selector'score |
|
691 |
""" |
|
692 |
assert selectors |
|
759
e044f28372bd
chainall / chainfirst ensures selectors are instantiated
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
741
diff
changeset
|
693 |
# XXX do we need to create the AndSelector here, a tuple might be enough |
780
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
694 |
selector = AndSelector(*selectors) |
693
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
695 |
if 'name' in kwargs: |
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
696 |
selector.__name__ = kwargs['name'] |
0 | 697 |
return selector |
698 |
||
693
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
699 |
def chainfirst(*selectors, **kwargs): |
0 | 700 |
"""return a selector chaining given selectors. If all |
701 |
the selectors fail, selection will fail, else the returned score |
|
702 |
will be the first non-zero selector score |
|
703 |
""" |
|
704 |
assert selectors |
|
780
5b6c93816871
fix selector search and refactor auto-instantiation
sylvain.thenault@logilab.fr
parents:
760
diff
changeset
|
705 |
selector = OrSelector(*selectors) |
693
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
706 |
if 'name' in kwargs: |
cf0817dfc787
reimplements chainall/chainfirst using [And/Or], implemenent search_selector function on Selector base class
sylvain.thenault@logilab.fr
parents:
686
diff
changeset
|
707 |
selector.__name__ = kwargs['name'] |
0 | 708 |
return selector |