370392444

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/zopefoundation/grokcore.component/commit/<a class=hub.com/zopefoundation/grokcore.component/commit/0898efa7538d29a4eb556b4047102ee4b8a2d7aa">0898efa75<a href="https://github.com/zopefoundation/grokcore.component/commit/0898efa7538d29a4eb556b4047102ee4b8a2d7aa">">Merge </a><a class="double-link" href="https://github.com/zopefoundation/grokcore.component/commit/<a class="double-link" href="https://github.com/zopefoundation/grokcore.component/commit/6f63e5777242ba953501c9b84ebb839f8fec3417">6f63e5777</a>">6f63e5777</a><a href="https://github.com/zopefoundation/grokcore.component/commit/0898efa7538d29a4eb556b4047102ee4b8a2d7aa"> into f6add2797">f6add2797</a>

Pull Request Pull Request #13: Config with pure python + setup GHA.

Run Details

241 of 264 branches covered (91.29%)

Branch coverage included in aggregate %.

23 of 23 new or added lines in 18 files covered. (100.0%)

1374 of 1411 relevant lines covered (97.38%)

0.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.86

/src/grokcore/component/directive.py

##############################################################################
#
# Copyright (c) 2006-2007 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Grok directives.
"""
import martian
import martian.util
from martian.error import GrokError, GrokImportError
from martian.util import scan_for_classes
from zope import interface
from zope.interface.interfaces import IInterface
from grokcore.component.interfaces import IContext


class global_utility(martian.MultipleTimesDirective):
    """Registers an instance of ``class`` (or ``class`` itself, depending on
    the value of the ``direct`` parameter) as a global utility.

    This allows you to register global utilities that don't inherit from the
    ``GlobalUtility`` base class.

    :param class: The class to register as a global utility.
    :param provides: Optionally, the interface the utility will provide.
    :param name: Optionally, a name for a named utility registration.
    :type name: string or unicode
    :param direct: Optionally, a flag indicating the class directly provides
                   the interfaces, and it needs not to be instantiated.
    :type direct: boolean
    """
    scope = martian.MODULE

    def factory(self, factory, provides=None, name=u'', direct=False):
        if provides is not None and not IInterface.providedBy(provides):
            raise GrokImportError(
                "You can only pass an interface to the "
                "provides argument of %s." % self.name)
        return (factory, provides, name, direct)


class global_adapter(martian.MultipleTimesDirective):
    """Registers the ``factory`` callable as a global adapter.

    This allows you to register global adapters that
    don't inherit from the ``Adapter`` or ``MultiAdapter`` base classes.

    :param factory: The class that implements the adaptation.
    :param adapts: Optionally, a single interface or a tuple of multiple
                   interfaces to adapts from. If omitted, this information is
                   deduced from the annotation on the factory. If no adapted
                   interface can be determined the current context will be
                   assumed.
    :param provides: Optionally, the interface the adapter will provide. If
                     omitted, this information is deduced from the annotations
                     on the factory.
    :param name: Optionally, a name for a named adapter registration.
    :type name: string or unicode

    """
    scope = martian.MODULE

    def factory(self, factory, adapts=None, provides=None, name=None):
        if provides is not None and not IInterface.providedBy(provides):
            raise GrokImportError(
                "You can only pass an interface to the "
                "provides argument of %s." % self.name)
        if adapts is None:
            adapts = getattr(factory, '__component_adapts__', None)
        elif not isinstance(adapts, (list, tuple,)):
            adapts = (adapts,)
        elif isinstance(adapts, list):
            adapts = tuple(adapts)

        return (factory, adapts, provides, name)


class name(martian.Directive):
    """Declares the name of a named utility, named adapter, etc.

    """
    scope = martian.CLASS
    store = martian.ONCE
    validate = martian.validateText
    default = u''


class context(martian.Directive):
    """Declares the type of object that the adapter (or a similar context-
    dependent component) adapts.

    :param context: Interface (in this case all objects providing this
                    interface will be eligible contexts for the adaptation) or
                    a class (then only instances of that particular class are
                    eligible).
    """

    scope = martian.CLASS_OR_MODULE
    store = martian.ONCE
    validate = martian.validateInterfaceOrClass

    @classmethod
    def get_default(cls, component, module=None, **data):
        components = list(scan_for_classes(module, IContext))
        if len(components) == 0:
            raise GrokError(
                "No module-level context for %r, please use the 'context' "
                "directive." % (component), component)
        elif len(components) == 1:
            component = components[0]
        else:
            raise GrokError(
                "Multiple possible contexts for %r, please use the 'context' "
                "directive."
                % (component), component)
        return component


class title(martian.Directive):
    """Declares the human-readable title of a component (such as a permission,
    role, etc.)

    """
    scope = martian.CLASS
    store = martian.ONCE
    validate = martian.validateText


class description(title):
    pass


class direct(martian.MarkerDirective):
    """Declares that a ``GlobalUtility`` class should be registered as a
    utility itself, rather than an instance of it.

    """
    scope = martian.CLASS


class order(martian.Directive):
    scope = martian.CLASS
    store = martian.ONCE
    default = 0, 0

    _order = 0

    def factory(self, value=0):
        order._order += 1
        return value, order._order


class path(martian.Directive):
    scope = martian.CLASS
    store = martian.ONCE
    validate = martian.validateText


class provides(martian.Directive):
    """Declares the interface that a adapter or utility provides for the
    registration, as opposed to potentially multiple interfaces that the class
    implements.

    :param interface: The interface the registered component will provide.

    """
    scope = martian.CLASS
    store = martian.ONCE
    validate = martian.validateInterface

    @classmethod
    def get_default(cls, component, module, **data):
        martian.util.check_implements_one(component)
        return list(interface.implementedBy(component))[0]


class implements(martian.Directive):
    """ Declare interfaces implemented by instances of a class.
        The arguments are one or more interfaces or interface
        specifications (IDeclaration objects).

        Since the original implementer from zope.interface is not supported
        anymore Python 3, grokcore.component continues to support it
        on its own.

        :param interface or interfaces to be implement by a class.
    """
    scope = martian.CLASS
    store = martian.ONCE
    default = None

    def factory(self, *interfaces):
        for iface in interfaces:
            if not IInterface.providedBy(iface):
                raise Exception('%s is not a interface' % repr(iface))
        return interfaces

1	##############################################################################
2	#
3	# Copyright (c) 2006-2007 Zope Foundation and Contributors.
4	# All Rights Reserved.
5	#
6	# This software is subject to the provisions of the Zope Public License,
7	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
8	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11	# FOR A PARTICULAR PURPOSE.
12	#
13	##############################################################################
14	"""Grok directives.	1✔
15	"""
16	import martian	1✔
17	import martian.util	1✔
18	from martian.error import GrokError, GrokImportError	1✔
19	from martian.util import scan_for_classes	1✔
20	from zope import interface	1✔
21	from zope.interface.interfaces import IInterface	1✔
22	from grokcore.component.interfaces import IContext	1✔
23
24
25	class global_utility(martian.MultipleTimesDirective):	1✔
26	"""Registers an instance of ``class`` (or ``class`` itself, depending on
27	the value of the ``direct`` parameter) as a global utility.
28
29	This allows you to register global utilities that don't inherit from the
30	``GlobalUtility`` base class.
31
32	:param class: The class to register as a global utility.
33	:param provides: Optionally, the interface the utility will provide.
34	:param name: Optionally, a name for a named utility registration.
35	:type name: string or unicode
36	:param direct: Optionally, a flag indicating the class directly provides
37	the interfaces, and it needs not to be instantiated.
38	:type direct: boolean
39	"""
40	scope = martian.MODULE	1✔
41
42	def factory(self, factory, provides=None, name=u'', direct=False):	1✔
43	if provides is not None and not IInterface.providedBy(provides):	1!
44	raise GrokImportError(	×
45	"You can only pass an interface to the "
46	"provides argument of %s." % self.name)
47	return (factory, provides, name, direct)	1✔
48
49
50	class global_adapter(martian.MultipleTimesDirective):	1✔
51	"""Registers the ``factory`` callable as a global adapter.
52
53	This allows you to register global adapters that
54	don't inherit from the ``Adapter`` or ``MultiAdapter`` base classes.
55
56	:param factory: The class that implements the adaptation.
57	:param adapts: Optionally, a single interface or a tuple of multiple
58	interfaces to adapts from. If omitted, this information is
59	deduced from the annotation on the factory. If no adapted
60	interface can be determined the current context will be
61	assumed.
62	:param provides: Optionally, the interface the adapter will provide. If
63	omitted, this information is deduced from the annotations
64	on the factory.
65	:param name: Optionally, a name for a named adapter registration.
66	:type name: string or unicode
67
68	"""
69	scope = martian.MODULE	1✔
70
71	def factory(self, factory, adapts=None, provides=None, name=None):	1✔
72	if provides is not None and not IInterface.providedBy(provides):	1!
73	raise GrokImportError(	×
74	"You can only pass an interface to the "
75	"provides argument of %s." % self.name)
76	if adapts is None:	1✔
77	adapts = getattr(factory, '__component_adapts__', None)	1✔
78	elif not isinstance(adapts, (list, tuple,)):	1✔
79	adapts = (adapts,)	1✔
80	elif isinstance(adapts, list):	1!
81	adapts = tuple(adapts)	×
82
83	return (factory, adapts, provides, name)	1✔
84
85
86	class name(martian.Directive):	1✔
87	"""Declares the name of a named utility, named adapter, etc.
88
89	"""
90	scope = martian.CLASS	1✔
91	store = martian.ONCE	1✔
92	validate = martian.validateText	1✔
93	default = u''	1✔
94
95
96	class context(martian.Directive):	1✔
97	"""Declares the type of object that the adapter (or a similar context-
98	dependent component) adapts.
99
100	:param context: Interface (in this case all objects providing this
101	interface will be eligible contexts for the adaptation) or
102	a class (then only instances of that particular class are
103	eligible).
104	"""
105
106	scope = martian.CLASS_OR_MODULE	1✔
107	store = martian.ONCE	1✔
108	validate = martian.validateInterfaceOrClass	1✔
109
110	@classmethod	1✔
111	def get_default(cls, component, module=None, **data):	1✔
112	components = list(scan_for_classes(module, IContext))	1✔
113	if len(components) == 0:	1✔
114	raise GrokError(	1✔
115	"No module-level context for %r, please use the 'context' "
116	"directive." % (component), component)
117	elif len(components) == 1:	1✔
118	component = components[0]	1✔
119	else:
120	raise GrokError(	1✔
121	"Multiple possible contexts for %r, please use the 'context' "
122	"directive."
123	% (component), component)
124	return component	1✔
125
126
127	class title(martian.Directive):	1✔
128	"""Declares the human-readable title of a component (such as a permission,
129	role, etc.)
130
131	"""
132	scope = martian.CLASS	1✔
133	store = martian.ONCE	1✔
134	validate = martian.validateText	1✔
135
136
137	class description(title):	1✔
138	pass	1✔
139
140
141	class direct(martian.MarkerDirective):	1✔
142	"""Declares that a ``GlobalUtility`` class should be registered as a
143	utility itself, rather than an instance of it.
144
145	"""
146	scope = martian.CLASS	1✔
147
148
149	class order(martian.Directive):	1✔
150	scope = martian.CLASS	1✔
151	store = martian.ONCE	1✔
152	default = 0, 0	1✔
153
154	_order = 0	1✔
155
156	def factory(self, value=0):	1✔
157	order._order += 1	1✔
158	return value, order._order	1✔
159
160
161	class path(martian.Directive):	1✔
162	scope = martian.CLASS	1✔
163	store = martian.ONCE	1✔
164	validate = martian.validateText	1✔
165
166
167	class provides(martian.Directive):	1✔
168	"""Declares the interface that a adapter or utility provides for the
169	registration, as opposed to potentially multiple interfaces that the class
170	implements.
171
172	:param interface: The interface the registered component will provide.
173
174	"""
175	scope = martian.CLASS	1✔
176	store = martian.ONCE	1✔
177	validate = martian.validateInterface	1✔
178
179	@classmethod	1✔
180	def get_default(cls, component, module, **data):	1✔
181	martian.util.check_implements_one(component)	1✔
182	return list(interface.implementedBy(component))[0]	1✔
183
184
185	class implements(martian.Directive):	1✔
186	""" Declare interfaces implemented by instances of a class.
187	The arguments are one or more interfaces or interface
188	specifications (IDeclaration objects).
189
190	Since the original implementer from zope.interface is not supported
191	anymore Python 3, grokcore.component continues to support it
192	on its own.
193
194	:param interface or interfaces to be implement by a class.
195	"""
196	scope = martian.CLASS	1✔
197	store = martian.ONCE	1✔
198	default = None	1✔
199
200	def factory(self, *interfaces):	1✔
201	for iface in interfaces:	×
202	if not IInterface.providedBy(iface):	×
203	raise Exception('%s is not a interface' % repr(iface))	×
204	return interfaces	×

zopefoundation / grokcore.component / 370392444

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous