zope.componentvocabulary-1.0.1/000755 000766 000024 00000000000 11450302217 016456 5ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/CHANGES.txt000644 000766 000024 00000000530 11450302177 020272 0ustar00macstaff000000 000000 ======= CHANGES ======= 1.0.1 (2010-09-25) ------------------ - Added not declared but needed dependency on ``zope.component``. - Added test extra to declare test dependency on ``zope.component [test]``. 1.0 (2009-05-19) ---------------- * Initial public release, derived from zope.app.component and zope.app.interface to replace them. zope.componentvocabulary-1.0.1/COPYRIGHT.txt000644 000766 000024 00000000040 11446133170 020566 0ustar00macstaff000000 000000 Zope Foundation and Contributorszope.componentvocabulary-1.0.1/LICENSE.txt000644 000766 000024 00000004026 11446133170 020310 0ustar00macstaff000000 000000 Zope Public License (ZPL) Version 2.1 A copyright notice accompanies this license document that identifies the copyright holders. This license has been certified as open source. It has also been designated as GPL compatible by the Free Software Foundation (FSF). Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions in source code must retain the accompanying copyright notice, this list of conditions, and the following disclaimer. 2. Redistributions in binary form must reproduce the accompanying copyright notice, this list of conditions, and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Names of the copyright holders must not be used to endorse or promote products derived from this software without prior written permission from the copyright holders. 4. The right to distribute this software or to use it for any purpose does not give you the right to use Servicemarks (sm) or Trademarks (tm) of the copyright holders. Use of them is covered by separate agreement with the copyright holders. 5. If any files are modified, you must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. Disclaimer THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. zope.componentvocabulary-1.0.1/PKG-INFO000644 000766 000024 00000002412 11450302217 017552 0ustar00macstaff000000 000000 Metadata-Version: 1.0 Name: zope.componentvocabulary Version: 1.0.1 Summary: Component vocabularies Home-page: http://pypi.python.org/pypi/zope.componentvocabulary Author: Zope Foundation and Contributors Author-email: zope-dev@zope.org License: ZPL 2.1 Description: This package contains various vocabularies. ======= CHANGES ======= 1.0.1 (2010-09-25) ------------------ - Added not declared but needed dependency on ``zope.component``. - Added test extra to declare test dependency on ``zope.component [test]``. 1.0 (2009-05-19) ---------------- * Initial public release, derived from zope.app.component and zope.app.interface to replace them. Keywords: zope component architecture vocabulary Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: Zope Public License Classifier: Programming Language :: Python Classifier: Natural Language :: English Classifier: Operating System :: OS Independent Classifier: Topic :: Internet :: WWW/HTTP Classifier: Framework :: Zope3 zope.componentvocabulary-1.0.1/README.txt000644 000766 000024 00000000054 11446133170 020160 0ustar00macstaff000000 000000 This package contains various vocabularies. zope.componentvocabulary-1.0.1/bootstrap.py000644 000766 000024 00000003302 11446133170 021050 0ustar00macstaff000000 000000 ############################################################################## # # Copyright (c) 2006 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. # ############################################################################## """Bootstrap a buildout-based project Simply run this script in a directory containing a buildout.cfg. The script accepts buildout command-line options, so you can use the -c option to specify an alternate configuration file. """ import os, shutil, sys, tempfile, urllib2 tmpeggs = tempfile.mkdtemp() ez = {} exec urllib2.urlopen('http://peak.telecommunity.com/dist/ez_setup.py' ).read() in ez ez['use_setuptools'](to_dir=tmpeggs, download_delay=0) import pkg_resources cmd = 'from setuptools.command.easy_install import main; main()' if sys.platform == 'win32': cmd = '"%s"' % cmd # work around spawn lamosity on windows ws = pkg_resources.working_set assert os.spawnle( os.P_WAIT, sys.executable, sys.executable, '-c', cmd, '-mqNxd', tmpeggs, 'zc.buildout', dict(os.environ, PYTHONPATH= ws.find(pkg_resources.Requirement.parse('setuptools')).location ), ) == 0 ws.add_entry(tmpeggs) ws.require('zc.buildout') import zc.buildout.buildout zc.buildout.buildout.main(sys.argv[1:] + ['bootstrap']) shutil.rmtree(tmpeggs) zope.componentvocabulary-1.0.1/buildout.cfg000644 000766 000024 00000000627 11447364327 021013 0ustar00macstaff000000 000000 [buildout] develop = . parts = test coverage-test coverage-report [test] recipe = zc.recipe.testrunner eggs = zope.componentvocabulary [test] [coverage-test] recipe = zc.recipe.testrunner eggs = zope.componentvocabulary defaults = ['--coverage', '../../coverage'] [coverage-report] recipe = zc.recipe.egg eggs = z3c.coverage scripts = coverage=coverage-report arguments = ('coverage', 'coverage/report') zope.componentvocabulary-1.0.1/setup.cfg000644 000766 000024 00000000073 11450302217 020277 0ustar00macstaff000000 000000 [egg_info] tag_build = tag_date = 0 tag_svn_revision = 0 zope.componentvocabulary-1.0.1/setup.py000644 000766 000024 00000004220 11450302177 020173 0ustar00macstaff000000 000000 ############################################################################## # # Copyright (c) 2006 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. # ############################################################################## """Setup for zope.app.catalog package """ import os from setuptools import setup, find_packages def read(*rnames): return open(os.path.join(os.path.dirname(__file__), *rnames)).read() setup(name='zope.componentvocabulary', version='1.0.1', author='Zope Foundation and Contributors', author_email='zope-dev@zope.org', description='Component vocabularies', long_description=( read('README.txt') + '\n\n' + read('CHANGES.txt') ), keywords="zope component architecture vocabulary", classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: Zope Public License', 'Programming Language :: Python', 'Natural Language :: English', 'Operating System :: OS Independent', 'Topic :: Internet :: WWW/HTTP', 'Framework :: Zope3'], url='http://pypi.python.org/pypi/zope.componentvocabulary', license='ZPL 2.1', packages=find_packages('src'), package_dir={'': 'src'}, namespace_packages=['zope'], install_requires=[ 'setuptools', 'zope.component', 'zope.i18nmessageid', 'zope.interface', 'zope.schema', 'zope.security', ], extras_require=dict( test=[ 'zope.component [test]', ]), include_package_data=True, zip_safe=False, ) zope.componentvocabulary-1.0.1/src/000755 000766 000024 00000000000 11450302217 017245 5ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/src/zope/000755 000766 000024 00000000000 11450302217 020222 5ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/src/zope.componentvocabulary.egg-info/000755 000766 000024 00000000000 11450302217 026005 5ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/src/zope.componentvocabulary.egg-info/PKG-INFO000644 000766 000024 00000002412 11450302216 027100 0ustar00macstaff000000 000000 Metadata-Version: 1.0 Name: zope.componentvocabulary Version: 1.0.1 Summary: Component vocabularies Home-page: http://pypi.python.org/pypi/zope.componentvocabulary Author: Zope Foundation and Contributors Author-email: zope-dev@zope.org License: ZPL 2.1 Description: This package contains various vocabularies. ======= CHANGES ======= 1.0.1 (2010-09-25) ------------------ - Added not declared but needed dependency on ``zope.component``. - Added test extra to declare test dependency on ``zope.component [test]``. 1.0 (2009-05-19) ---------------- * Initial public release, derived from zope.app.component and zope.app.interface to replace them. Keywords: zope component architecture vocabulary Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Environment :: Web Environment Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: Zope Public License Classifier: Programming Language :: Python Classifier: Natural Language :: English Classifier: Operating System :: OS Independent Classifier: Topic :: Internet :: WWW/HTTP Classifier: Framework :: Zope3 zope.componentvocabulary-1.0.1/src/zope.componentvocabulary.egg-info/SOURCES.txt000644 000766 000024 00000001345 11450302216 027673 0ustar00macstaff000000 000000 CHANGES.txt COPYRIGHT.txt LICENSE.txt README.txt bootstrap.py buildout.cfg setup.py src/zope/__init__.py src/zope.componentvocabulary.egg-info/PKG-INFO src/zope.componentvocabulary.egg-info/SOURCES.txt src/zope.componentvocabulary.egg-info/dependency_links.txt src/zope.componentvocabulary.egg-info/namespace_packages.txt src/zope.componentvocabulary.egg-info/not-zip-safe src/zope.componentvocabulary.egg-info/requires.txt src/zope.componentvocabulary.egg-info/top_level.txt src/zope/componentvocabulary/__init__.py src/zope/componentvocabulary/configure.zcml src/zope/componentvocabulary/i18n.py src/zope/componentvocabulary/vocabulary.py src/zope/componentvocabulary/tests/__init__.py src/zope/componentvocabulary/tests/test_vocabulary.pyzope.componentvocabulary-1.0.1/src/zope.componentvocabulary.egg-info/dependency_links.txt000644 000766 000024 00000000001 11450302216 032052 0ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/src/zope.componentvocabulary.egg-info/namespace_packages.txt000644 000766 000024 00000000005 11450302216 032332 0ustar00macstaff000000 000000 zope zope.componentvocabulary-1.0.1/src/zope.componentvocabulary.egg-info/not-zip-safe000644 000766 000024 00000000001 11446133205 030237 0ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/src/zope.componentvocabulary.egg-info/requires.txt000644 000766 000024 00000000163 11450302216 030404 0ustar00macstaff000000 000000 setuptools zope.component zope.i18nmessageid zope.interface zope.schema zope.security [test] zope.component [test]zope.componentvocabulary-1.0.1/src/zope.componentvocabulary.egg-info/top_level.txt000644 000766 000024 00000000005 11450302216 030531 0ustar00macstaff000000 000000 zope zope.componentvocabulary-1.0.1/src/zope/__init__.py000644 000766 000024 00000000311 11446133170 022333 0ustar00macstaff000000 000000 # this is a namespace package try: import pkg_resources pkg_resources.declare_namespace(__name__) except ImportError: import pkgutil __path__ = pkgutil.extend_path(__path__, __name__) zope.componentvocabulary-1.0.1/src/zope/componentvocabulary/000755 000766 000024 00000000000 11450302217 024314 5ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/src/zope/componentvocabulary/__init__.py000644 000766 000024 00000001233 11446133170 026431 0ustar00macstaff000000 000000 ############################################################################## # # Copyright (c) 2004 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. # ############################################################################## """Component vocabularies. """ zope.componentvocabulary-1.0.1/src/zope/componentvocabulary/configure.zcml000644 000766 000024 00000001256 11446133170 027175 0ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/src/zope/componentvocabulary/i18n.py000644 000766 000024 00000001572 11446133170 025457 0ustar00macstaff000000 000000 ############################################################################## # # Copyright (c) 2003 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. # ############################################################################## """Customization of zope.i18n for the Zope application server """ __docformat__ = 'restructuredtext' # import this as _ to create i18n messages in the zope domain from zope.i18nmessageid import MessageFactory ZopeMessageFactory = MessageFactory('zope') zope.componentvocabulary-1.0.1/src/zope/componentvocabulary/tests/000755 000766 000024 00000000000 11450302217 025456 5ustar00macstaff000000 000000 zope.componentvocabulary-1.0.1/src/zope/componentvocabulary/vocabulary.py000644 000766 000024 00000033101 11446133170 027040 0ustar00macstaff000000 000000 ############################################################################## # # Copyright (c) 2004 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. # ############################################################################## """Utility Vocabulary. This vocabulary provides terms for all utilities providing a given interface. """ __docformat__ = "reStructuredText" import zope.component from zope.component.interface import interfaceToName from zope.component.interfaces import IUtilityRegistration from zope.interface import implements, classProvides, Interface, providedBy from zope.interface.interfaces import IInterface from zope.security.proxy import removeSecurityProxy from zope.schema.interfaces import IVocabularyTokenized from zope.schema.interfaces import ITokenizedTerm, ITitledTokenizedTerm from zope.schema.interfaces import IVocabularyFactory from zope.schema.vocabulary import SimpleVocabulary, SimpleTerm from zope.componentvocabulary.i18n import ZopeMessageFactory as _ class UtilityTerm(object): """A term representing a utility. The token of the term is the name of the utility. Here is a brief example on how the IVocabulary interface is handled in this term as a utility: >>> from zope.interface.verify import verifyObject >>> from zope.schema.interfaces import IVocabulary >>> term = UtilityTerm(IVocabulary, 'zope.schema.interfaces.IVocabulary') >>> verifyObject(ITokenizedTerm, term) True >>> term.value >>> term.token 'zope.schema.interfaces.IVocabulary' >>> term """ implements(ITokenizedTerm) def __init__(self, value, token): """Create a term for value and token.""" self.value = value self.token = token def __repr__(self): return '' %( self.token, self.value.__class__.__name__) class UtilityVocabulary(object): """Vocabulary that provides utilities of a specified interface. Here is a short example of how the vocabulary should work. First we need to create a utility interface and some utilities: >>> class IObject(Interface): ... 'Simple interface to mark object utilities.' >>> >>> class Object(object): ... implements(IObject) ... def __init__(self, name): ... self.name = name ... def __repr__(self): ... return '' %self.name Now we register some utilities for IObject >>> from zope import component >>> object1 = Object('object1') >>> component.provideUtility(object1, IObject, 'object1') >>> object2 = Object('object2') >>> component.provideUtility(object2, IObject, 'object2') >>> object3 = Object('object3') >>> component.provideUtility(object3, IObject, 'object3') >>> object4 = Object('object4') We are now ready to create a vocabulary that we can use; in our case everything is global, so the context is None. >>> vocab = UtilityVocabulary(None, interface=IObject) >>> import pprint >>> pprint.pprint(vocab._terms.items()) [(u'object1', ), (u'object2', ), (u'object3', )] Now let's see how the other methods behave in this context. First we can just use the 'in' opreator to test whether a value is available. >>> object1 in vocab True >>> object4 in vocab False We can also create a lazy iterator. Note that the utility terms might appear in a different order than the utilities were registered. >>> iterator = iter(vocab) >>> terms = list(iterator) >>> names = [term.token for term in terms] >>> names.sort() >>> names [u'object1', u'object2', u'object3'] Determining the amount of utilities available via the vocabulary is also possible. >>> len(vocab) 3 Next we are looking at some of the more vocabulary-characteristic API methods. One can get a term for a given value using ``getTerm()``: >>> vocab.getTerm(object1) >>> vocab.getTerm(object4) Traceback (most recent call last): ... LookupError: On the other hand, if you want to get a term by the token, then you do that with: >>> vocab.getTermByToken('object1') >>> vocab.getTermByToken('object4') Traceback (most recent call last): ... LookupError: object4 That's it. It is all pretty straight forward, but it allows us to easily create a vocabulary for any utility. In fact, to make it easy to register such a vocabulary via ZCML, the `interface` argument to the constructor can be a string that is resolved via the utility registry. The ZCML looks like this: >>> component.provideUtility(IObject, IInterface, ... 'zope.app.utility.vocabulary.IObject') >>> vocab = UtilityVocabulary( ... None, interface='zope.app.utility.vocabulary.IObject') >>> pprint.pprint(vocab._terms.items()) [(u'object1', ), (u'object2', ), (u'object3', )] Sometimes it is desirable to only select the name of a utility. For this purpose a `nameOnly` argument was added to the constructor, in which case the UtilityTerm's value is not the utility itself but the name of the utility. >>> vocab = UtilityVocabulary(None, interface=IObject, nameOnly=True) >>> pprint.pprint([term.value for term in vocab]) [u'object1', u'object2', u'object3'] """ implements(IVocabularyTokenized) classProvides(IVocabularyFactory) # override these in subclasses interface = Interface nameOnly = False def __init__(self, context, **kw): if kw: # BBB 2006/02/24, to be removed after 12 months # the 'interface' and 'nameOnly' parameters are supposed to be # set as class-level attributes in custom subclasses now. self.nameOnly = bool(kw.get('nameOnly', False)) interface = kw.get('interface', Interface) if isinstance(interface, (str, unicode)): interface = zope.component.getUtility(IInterface, interface) self.interface = interface utils = zope.component.getUtilitiesFor(self.interface, context) self._terms = dict( (name, UtilityTerm(self.nameOnly and name or util, name)) for name, util in utils) def __contains__(self, value): """See zope.schema.interfaces.IBaseVocabulary""" return value in (term.value for term in self._terms.values()) def getTerm(self, value): """See zope.schema.interfaces.IBaseVocabulary""" try: return [term for name, term in self._terms.items() if term.value == value][0] except IndexError: raise LookupError(value) def getTermByToken(self, token): """See zope.schema.interfaces.IVocabularyTokenized""" try: return self._terms[token] except KeyError: raise LookupError(token) def __iter__(self): """See zope.schema.interfaces.IIterableVocabulary""" # Sort the terms by the token (utility name) values = self._terms.values() values.sort(lambda x, y: cmp(x.token, y.token)) return iter(values) def __len__(self): """See zope.schema.interfaces.IIterableVocabulary""" return len(self._terms) class InterfacesVocabulary(UtilityVocabulary): classProvides(IVocabularyFactory) interface = IInterface class ObjectInterfacesVocabulary(SimpleVocabulary): """A vocabulary that provides a list of all interfaces that its context provides. Here a quick demonstration: >>> from zope.interface import Interface, implements >>> class I1(Interface): ... pass >>> class I2(Interface): ... pass >>> class I3(I2): ... pass >>> class Object(object): ... implements(I3, I1) >>> vocab = ObjectInterfacesVocabulary(Object()) >>> import pprint >>> names = [term.token for term in vocab] >>> names.sort() >>> pprint.pprint(names) ['zope.componentvocabulary.vocabulary.I1', 'zope.componentvocabulary.vocabulary.I2', 'zope.componentvocabulary.vocabulary.I3', 'zope.interface.Interface'] """ classProvides(IVocabularyFactory) def __init__(self, context): # Remove the security proxy so the values from the vocabulary # are the actual interfaces and not proxies. component = removeSecurityProxy(context) interfaces = providedBy(component).flattened() terms = [SimpleTerm(interface, interfaceToName(context, interface)) for interface in interfaces] super(ObjectInterfacesVocabulary, self).__init__(terms) class UtilityComponentInterfacesVocabulary(ObjectInterfacesVocabulary): classProvides(IVocabularyFactory) def __init__(self, context): if IUtilityRegistration.providedBy(context): context = context.component super(UtilityComponentInterfacesVocabulary, self).__init__( context) class UtilityNameTerm: r"""Simple term that provides a utility name as a value. >>> t1 = UtilityNameTerm('abc') >>> t2 = UtilityNameTerm(u'\xC0\xDF\xC7') >>> t1.value u'abc' >>> t2.value u'\xc0\xdf\xc7' >>> t1.title u'abc' >>> repr(t2.title) "u'\\xc0\\xdf\\xc7'" >>> ITitledTokenizedTerm.providedBy(t1) True The tokens used for form values are Base-64 encodings of the names, with the letter 't' prepended to ensure the unnamed utility is supported: >>> t1.token 'tYWJj' >>> t2.token 'tw4DDn8OH' The unnamed utility is given an artificial title for use in user interfaces: >>> t3 = UtilityNameTerm(u'') >>> t3.title u'(unnamed utility)' """ implements(ITitledTokenizedTerm) def __init__(self, value): self.value = unicode(value) @property def token(self): # Return our value as a token. This is required to be 7-bit # printable ascii. We'll use base64 generated from the UTF-8 # representation. (The default encoding rules should not be # allowed to apply.) return "t" + self.value.encode('utf-8').encode('base64')[:-1] @property def title(self): return self.value or _("(unnamed utility)") class UtilityNames: """Vocabulary with utility names for a single interface as values. >>> class IMyUtility(Interface): ... pass >>> class MyUtility(object): ... implements(IMyUtility) >>> vocab = UtilityNames(IMyUtility) >>> from zope.schema.interfaces import IVocabulary >>> IVocabulary.providedBy(vocab) True >>> IVocabularyTokenized.providedBy(vocab) True >>> from zope.component.testing import PlacelessSetup >>> from zope import component >>> ps = PlacelessSetup() >>> ps.setUp() >>> component.provideUtility(MyUtility(), IMyUtility, 'one') >>> component.provideUtility(MyUtility(), IMyUtility, 'two') >>> unames = UtilityNames(IMyUtility) >>> len(list(unames)) 2 >>> L = [t.value for t in unames] >>> L.sort() >>> L [u'one', u'two'] >>> u'one' in vocab True >>> u'three' in vocab False >>> component.provideUtility(MyUtility(), IMyUtility, 'three') >>> u'three' in vocab True >>> component.provideUtility(MyUtility(), IMyUtility) >>> u'' in vocab True >>> term1 = vocab.getTerm(u'') >>> term2 = vocab.getTermByToken(term1.token) >>> term2.value u'' >>> term3 = vocab.getTerm(u'one') >>> term3.token 'tb25l' >>> term3a = vocab.getTermByToken('tb25l') >>> term3.value u'one' >>> ps.tearDown() """ implements(IVocabularyTokenized) def __init__(self, interface): self.interface = interface def __contains__(self, value): return zope.component.queryUtility(self.interface, value) is not None def getTerm(self, value): if value in self: return UtilityNameTerm(value) raise ValueError(value) def getTermByToken(self, token): for name, ut in zope.component.getUtilitiesFor(self.interface): name = unicode(name) if token == "t": if not name: break elif UtilityNameTerm(name).token == token: break else: raise LookupError("no matching token: %r" % token) return self.getTerm(name) def __iter__(self): for name, ut in zope.component.getUtilitiesFor(self.interface): yield UtilityNameTerm(name) def __len__(self): """Return the number of valid terms, or sys.maxint.""" return len(list(zope.component.getUtilitiesFor(self.interface))) zope.componentvocabulary-1.0.1/src/zope/componentvocabulary/tests/__init__.py000644 000766 000024 00000000075 11446133170 027576 0ustar00macstaff000000 000000 # # This file is necessary to make this directory a package. zope.componentvocabulary-1.0.1/src/zope/componentvocabulary/tests/test_vocabulary.py000644 000766 000024 00000001441 11446133170 031243 0ustar00macstaff000000 000000 ############################################################################## # # Copyright (c) 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. # ############################################################################## """Vocabulary tests """ __docformat__ = "reStructuredText" import doctest def test_suite(): return doctest.DocTestSuite('zope.componentvocabulary.vocabulary')