[Checkins] SVN: grokcore.component/trunk/src/grok/ Removed everything from "grokcore.component" that wasn't needed to

Brandon Rhodes brandon at rhodesmill.org
Mon Mar 17 17:22:53 EDT 2008


Log message for revision 84750:
  Removed everything from "grokcore.component" that wasn't needed to
  power Grok adapters and utilities of all the various sorts.  This
  still includes a cheat so the tests can still use "grok.Model", which
  we shall now remove.
  

Changed:
  U   grokcore.component/trunk/src/grok/__init__.py
  D   grokcore.component/trunk/src/grok/admin/
  U   grokcore.component/trunk/src/grok/components.py
  U   grokcore.component/trunk/src/grok/configure.zcml
  U   grokcore.component/trunk/src/grok/decorators.py
  U   grokcore.component/trunk/src/grok/directive.py
  D   grokcore.component/trunk/src/grok/formlib.py
  D   grokcore.component/trunk/src/grok/index.py
  U   grokcore.component/trunk/src/grok/meta.py
  D   grokcore.component/trunk/src/grok/publication.py
  D   grokcore.component/trunk/src/grok/rest.py
  D   grokcore.component/trunk/src/grok/templatereg.py
  U   grokcore.component/trunk/src/grok/testing.py
  U   grokcore.component/trunk/src/grok/tests/directive/argumenterror.py
  U   grokcore.component/trunk/src/grok/tests/directive/argumenterror_fixture.py
  U   grokcore.component/trunk/src/grok/util.py
  U   grokcore.component/trunk/src/grok/zcml.py

-=-
Modified: grokcore.component/trunk/src/grok/__init__.py
===================================================================
--- grokcore.component/trunk/src/grok/__init__.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/__init__.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -16,46 +16,21 @@
 
 from zope.interface import implements
 from zope.component import adapts
-from zope.event import notify
-from zope.app.component.hooks import getSite
-from zope.lifecycleevent import (
-    IObjectCreatedEvent, ObjectCreatedEvent,
-    IObjectModifiedEvent, ObjectModifiedEvent,
-    IObjectCopiedEvent, ObjectCopiedEvent)
 
-from zope.app.container.contained import (
-    IObjectAddedEvent, ObjectAddedEvent,
-    IObjectMovedEvent, ObjectMovedEvent,
-    IObjectRemovedEvent, ObjectRemovedEvent,
-    IContainerModifiedEvent, ContainerModifiedEvent)
-
 from martian import ClassGrokker, InstanceGrokker, GlobalGrokker
-from grok.components import Model, Adapter, MultiAdapter, View
-from grok.components import XMLRPC, REST, JSON
-from grok.components import PageTemplate, PageTemplateFile, Container, Traverser
-from grok.components import Site, GlobalUtility, LocalUtility, Annotation
-from grok.components import Application, Form, AddForm, EditForm, DisplayForm
-from grok.components import Indexes
-from grok.components import Permission, Role
-from grok.components import Skin, IGrokLayer
-from grok.components import RESTProtocol, IRESTLayer
-from grok.interfaces import IRESTSkinType
-from grok.components import ViewletManager, Viewlet
+from grok.components import Adapter, GlobalUtility, MultiAdapter, Context
+from grok.components import Context as Model
 
-from grok.directive import (context, name, title, template, templatedir,
-                            provides, baseclass, global_utility, local_utility,
-                            permissions, require, site, layer, direct, viewletmanager,
-                            view, order)
-from grok.decorators import subscribe, adapter, implementer
+from grok.directive import (context, name, title,
+                            provides, baseclass, global_utility,
+                            direct, order)
+from grok.decorators import adapter, implementer
 from martian.error import GrokError, GrokImportError
 
 # BBB These two functions are meant for test fixtures and should be
 # imported from grok.testing, not from grok.
 from grok.testing import grok, grok_component
 
-from grok.formlib import action, AutoFields, Fields
-from grok.util import url
-
 # Our __init__ provides the grok API directly so using 'import grok' is enough.
 from grok.interfaces import IGrokAPI
 from zope.interface import moduleProvides

Modified: grokcore.component/trunk/src/grok/components.py
===================================================================
--- grokcore.component/trunk/src/grok/components.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/components.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -13,701 +13,15 @@
 ##############################################################################
 """Grok components"""
 
-import sys
-import os
-import persistent
-import datetime
-import warnings
-import pytz
-import simplejson
-
-from zope import component
-from zope import interface
-from zope.interface.common import idatetime
-from zope.security.permission import Permission
-from zope.securitypolicy.role import Role
-from zope.publisher.browser import BrowserPage
-from zope.publisher.interfaces import NotFound
-from zope.publisher.interfaces.browser import (IBrowserPublisher,
-                                               IBrowserRequest)
-from zope.publisher.publish import mapply
-from zope.pagetemplate import pagetemplate, pagetemplatefile
-from zope.formlib import form
-from zope.annotation.interfaces import IAttributeAnnotatable
-
-from zope.app.pagetemplate.engine import TrustedAppPT
-from zope.app.publisher.browser import getDefaultViewName
-from zope.app.publisher.browser import directoryresource
-from zope.app.publisher.browser.pagetemplateresource import \
-    PageTemplateResourceFactory
-from zope.app.container.btree import BTreeContainer
-from zope.app.container.contained import Contained
-from zope.app.container.interfaces import IReadContainer, IObjectAddedEvent
-from zope.app.component.site import SiteManagerContainer
-from zope.app.component.site import LocalSiteManager
-
-from zope.viewlet.manager import ViewletManagerBase
-from zope.viewlet.viewlet import ViewletBase
-
-import z3c.flashmessage.interfaces
-
-import martian.util
-from grok import interfaces, formlib, util
-
-
-class Model(Contained, persistent.Persistent):
-    # XXX Inheritance order is important here. If we reverse this,
-    # then containers can't be models anymore because no unambigous MRO
-    # can be established.
-    interface.implements(IAttributeAnnotatable)
-
-
-class Container(BTreeContainer):
-    interface.implements(IAttributeAnnotatable)
-
-
-class Site(SiteManagerContainer):
-    pass
-
- at component.adapter(Site, IObjectAddedEvent)
-def addSiteHandler(site, event):
-    sitemanager = LocalSiteManager(site)
-    # LocalSiteManager creates the 'default' folder in its __init__.
-    # It's not needed anymore in new versions of Zope 3, therefore we
-    # remove it
-    del sitemanager['default']
-    site.setSiteManager(sitemanager)
-
-
-class Application(Site):
-    """A top-level application object."""
-    interface.implements(interfaces.IApplication)
-
-
 class Adapter(object):
-
     def __init__(self, context):
         self.context = context
 
-
 class GlobalUtility(object):
     pass
 
-
-class LocalUtility(Model):
-    pass
-
-
 class MultiAdapter(object):
     pass
 
-
-class Annotation(persistent.Persistent):
+class Context(object):
     pass
-
-
-class ViewBase(object):
-    def __init__(self, context, request):
-        self.context = context
-        self.request = request
-
-class View(BrowserPage):
-    interface.implements(interfaces.IGrokView)
-
-    def __init__(self, context, request):
-        super(View, self).__init__(context, request)
-        self.__name__ = self.__view_name__
-        self.static = component.queryAdapter(
-            self.request,
-            interface.Interface,
-            name=self.module_info.package_dotted_name
-            )
-
-    @property
-    def response(self):
-        return self.request.response
-
-    def __call__(self):
-        mapply(self.update, (), self.request)
-        if self.request.response.getStatus() in (302, 303):
-            # A redirect was triggered somewhere in update().  Don't
-            # continue rendering the template or doing anything else.
-            return
-
-        template = getattr(self, 'template', None)
-        if template is not None:
-            return self._render_template()
-        return mapply(self.render, (), self.request)
-
-    def _render_template(self):
-        return self.template.render(self)
-
-    def namespace(self):
-        return {}
-
-    def __getitem__(self, key):
-        # This is BBB code for Zope page templates only:
-        if not isinstance(self.template, PageTemplate):
-            raise AttributeError("View has no item %s" % key)
-
-        value = self.template._template.macros[key]
-        # When this deprecation is done with, this whole __getitem__ can
-        # be removed.
-        warnings.warn("Calling macros directly on the view is deprecated. "
-                      "Please use context/@@viewname/macros/macroname\n"
-                      "View %r, macro %s" % (self, key),
-                      DeprecationWarning, 1)
-        return value
-
-
-    def url(self, obj=None, name=None):
-        # if the first argument is a string, that's the name. There should
-        # be no second argument
-        if isinstance(obj, basestring):
-            if name is not None:
-                raise TypeError(
-                    'url() takes either obj argument, obj, string arguments, '
-                    'or string argument')
-            name = obj
-            obj = None
-
-        if name is None and obj is None:
-            # create URL to view itself
-            obj = self
-        elif name is not None and obj is None:
-            # create URL to view on context
-            obj = self.context
-        return util.url(self.request, obj, name)
-
-    def application_url(self, name=None):
-        obj = self.context
-        while obj is not None:
-            if isinstance(obj, Application):
-                return self.url(obj, name)
-            obj = obj.__parent__
-        raise ValueError("No application found.")
-
-    def redirect(self, url):
-        return self.request.response.redirect(url)
-
-    def update(self):
-        pass
-
-    def flash(self, message, type='message'):
-        source = component.getUtility(
-            z3c.flashmessage.interfaces.IMessageSource, name='session')
-        source.send(message, type)
-
-
-class XMLRPC(object):
-    pass
-
-class REST(object):
-    interface.implements(interfaces.IREST)
-
-    def __init__(self, context, request):
-        self.context = context
-        self.request = request
-        self.body = request.bodyStream.getCacheStream().read()
-
-    @property
-    def response(self):
-        return self.request.response
-
-##     def GET(self):
-##         raise GrokMethodNotAllowed(self.context, self.request)
-
-##     def POST(self):
-##         raise GrokMethodNotAllowed(self.context, self.request)
-
-##     def PUT(self):
-##         raise GrokMethodNotAllowed(self.context, self.request)
-
-##     def DELETE(self):
-##         raise GrokMethodNotAllowed(self.context, self.request)
-
-class JSON(BrowserPage):
-
-    def __call__(self):
-        view_name = self.__view_name__
-        method = getattr(self, view_name)
-        method_result = mapply(method, (), self.request)
-        return simplejson.dumps(method_result)
-
-
-class BaseTemplate(object):
-    """Any sort of page template"""
-
-    interface.implements(interfaces.ITemplate)
-
-    __grok_name__ = ''
-    __grok_location__ = ''
-
-    def __repr__(self):
-        return '<%s template in %s>' % (self.__grok_name__,
-                                        self.__grok_location__)
-
-    def _annotateGrokInfo(self, name, location):
-        self.__grok_name__ = name
-        self.__grok_location__ = location
-
-    def _initFactory(self, factory):
-        pass
-
-
-class GrokTemplate(BaseTemplate):
-    """A slightly more advanced page template
-
-    This provides most of what a page template needs and is a good base for
-    writing your own page template"""
-
-    def __init__(self, string=None, filename=None, _prefix=None):
-
-        # __grok_module__ is needed to make defined_locally() return True for
-        # inline templates
-        # XXX unfortunately using caller_module means that care must be taken
-        # when GrokTemplate is subclassed. You can not do a super().__init__
-        # for example.
-        self.__grok_module__ = martian.util.caller_module()
-
-        if not (string is None) ^ (filename is None):
-            raise AssertionError("You must pass in template or filename, but not both.")
-
-        if string:
-            self.setFromString(string)
-        else:
-            if _prefix is None:
-                module = sys.modules[self.__grok_module__]
-                _prefix = os.path.dirname(module.__file__)
-            self.setFromFilename(filename, _prefix)
-
-    def __repr__(self):
-        return '<%s template in %s>' % (self.__grok_name__,
-                                        self.__grok_location__)
-
-    def _annotateGrokInfo(self, name, location):
-        self.__grok_name__ = name
-        self.__grok_location__ = location
-
-    def _initFactory(self, factory):
-        pass
-
-    def namespace(self, view):
-        namespace = {}
-        namespace['request'] = view.request
-        namespace['view'] = view
-        namespace['context'] = view.context
-        # XXX need to check whether we really want to put None here if missing
-        namespace['static'] = view.static
-
-        return namespace
-
-    def getNamespace(self, view):
-        namespace = self.namespace(view)
-        namespace.update(view.namespace())
-        return namespace
-
-class TrustedPageTemplate(TrustedAppPT, pagetemplate.PageTemplate):
-    pass
-
-class TrustedFilePageTemplate(TrustedAppPT, pagetemplatefile.PageTemplateFile):
-    pass
-
-class PageTemplate(GrokTemplate):
-
-    def setFromString(self, string):
-        zpt = TrustedPageTemplate()
-        if martian.util.not_unicode_or_ascii(string):
-            raise ValueError("Invalid page template. Page templates must be "
-                             "unicode or ASCII.")
-        zpt.write(string)
-        self._template = zpt
-
-    def setFromFilename(self, filename, _prefix=None):
-        self._template = TrustedFilePageTemplate(filename, _prefix)
-
-    def _initFactory(self, factory):
-        factory.macros = self._template.macros
-
-    def render(self, view):
-        namespace = self.getNamespace(view)
-        template = self._template
-        namespace.update(template.pt_getContext())
-        return template.pt_render(namespace)
-
-class PageTemplateFile(PageTemplate):
-    # For BBB
-    def __init__(self, filename, _prefix=None):
-        self.__grok_module__ = martian.util.caller_module()
-        if _prefix is None:
-            module = sys.modules[self.__grok_module__]
-            _prefix = os.path.dirname(module.__file__)
-        self.setFromFilename(filename, _prefix)
-
-class DirectoryResource(directoryresource.DirectoryResource):
-    # We subclass this, because we want to override the default factories for
-    # the resources so that .pt and .html do not get created as page
-    # templates
-
-    resource_factories = {}
-    for type, factory in (directoryresource.DirectoryResource.
-                          resource_factories.items()):
-        if factory is PageTemplateResourceFactory:
-            continue
-        resource_factories[type] = factory
-
-
-class DirectoryResourceFactory(object):
-    # We need this to allow hooking up our own GrokDirectoryResource
-    # and to set the checker to None (until we have our own checker)
-
-    def __init__(self, path, name):
-        # XXX we're not sure about the checker=None here
-        self.__dir = directoryresource.Directory(path, None, name)
-        self.__name = name
-
-    def __call__(self, request):
-        resource = DirectoryResource(self.__dir, request)
-        resource.__name__ = self.__name
-        return resource
-
-
-class Traverser(object):
-    interface.implements(IBrowserPublisher)
-
-    def __init__(self, context, request):
-        self.context = context
-        self.request = request
-
-    def browserDefault(self, request):
-        # if we have a RESTful request, we will handle
-        # GET, POST and HEAD differently (PUT and DELETE are handled already
-        # but not on the BrowserRequest layer but the HTTPRequest layer)
-        if IRESTLayer.providedBy(request):
-            rest_view = component.getMultiAdapter(
-                (self.context, self.request),
-                name=request.method)
-            return rest_view, ()
-        view_name = getDefaultViewName(self.context, request)
-        view_uri = "@@%s" % view_name
-        return self.context, (view_uri,)
-
-    def publishTraverse(self, request, name):
-        subob = self.traverse(name)
-        if subob is not None:
-            return util.safely_locate_maybe(subob, self.context, name)
-
-        # XXX Special logic here to deal with containers.  It would be
-        # good if we wouldn't have to do this here. One solution is to
-        # rip this out and make you subclass ContainerTraverser if you
-        # wanted to override the traversal behaviour of containers.
-        if IReadContainer.providedBy(self.context):
-            item = self.context.get(name)
-            if item is not None:
-                return item
-
-        view = component.queryMultiAdapter((self.context, request), name=name)
-        if view is not None:
-            return view
-
-        raise NotFound(self.context, name, request)
-
-    def traverse(self, name):
-        # this will be overridden by subclasses
-        pass
-
-
-class ModelTraverser(Traverser):
-    component.adapts(Model, IBrowserRequest)
-
-    def traverse(self, name):
-        traverse = getattr(self.context, 'traverse', None)
-        if traverse:
-            return traverse(name)
-
-
-class ContainerTraverser(Traverser):
-    component.adapts(Container, IBrowserRequest)
-
-    def traverse(self, name):
-        traverse = getattr(self.context, 'traverse', None)
-        if traverse:
-            result = traverse(name)
-            if result is not None:
-                return result
-        # try to get the item from the container
-        return self.context.get(name)
-
-
-default_form_template = PageTemplateFile(os.path.join(
-    'templates', 'default_edit_form.pt'))
-default_form_template.__grok_name__ = 'default_edit_form'
-default_display_template = PageTemplateFile(os.path.join(
-    'templates', 'default_display_form.pt'))
-default_display_template.__grok_name__ = 'default_display_form'
-
-
-class GrokForm(object):
-    """Mix-in to consolidate zope.formlib's forms with grok.View and to
-    add some more useful methods.
-
-    The consolidation needs to happen because zope.formlib's Forms have
-    update/render methods which have different meanings than
-    grok.View's update/render methods.  We deal with this issue by
-    'renaming' zope.formlib's update() to update_form() and by
-    disallowing subclasses to have custom render() methods."""
-
-    def update(self):
-        """Subclasses can override this method just like on regular
-        grok.Views. It will be called before any form processing
-        happens."""
-
-    def update_form(self):
-        """Update the form, i.e. process form input using widgets.
-
-        On zope.formlib forms, this is what the update() method is.
-        In grok views, the update() method has a different meaning.
-        That's why this method is called update_form() in grok forms."""
-        super(GrokForm, self).update()
-
-    def render(self):
-        """Render the form, either using the form template or whatever
-        the actions returned in form_result."""
-        # if the form has been updated, it will already have a result
-        if self.form_result is None:
-            if self.form_reset:
-                # we reset, in case data has changed in a way that
-                # causes the widgets to have different data
-                self.resetForm()
-                self.form_reset = False
-            self.form_result = self._render_template()
-
-        return self.form_result
-
-    # Mark the render() method as a method from the base class. That
-    # way we can detect whether somebody overrides render() in a
-    # subclass (which we don't allow).
-    render.base_method = True
-
-    def __call__(self):
-        mapply(self.update, (), self.request)
-        if self.request.response.getStatus() in (302, 303):
-            # A redirect was triggered somewhere in update().  Don't
-            # continue rendering the template or doing anything else.
-            return
-
-        self.update_form()
-        return self.render()
-
-
-class Form(GrokForm, form.FormBase, View):
-    # We're only reusing the form implementation from zope.formlib, we
-    # explicitly don't want to inherit the interface semantics (mostly
-    # for the different meanings of update/render).
-    interface.implementsOnly(interfaces.IGrokForm)
-
-    template = default_form_template
-
-    def applyData(self, obj, **data):
-        return formlib.apply_data_event(obj, self.form_fields, data,
-                                        self.adapters)
-
-    # BBB -- to be removed in June 2007
-    def applyChanges(self, obj, **data):
-        warnings.warn("The 'applyChanges' method on forms is deprecated "
-                      "and will disappear by June 2007. Please use "
-                      "'applyData' instead.", DeprecationWarning, 2)
-        return bool(self.applyData(obj, **data))
-
-
-class AddForm(Form):
-    pass
-
-
-class EditForm(GrokForm, form.EditFormBase, View):
-    # We're only reusing the form implementation from zope.formlib, we
-    # explicitly don't want to inherit the interface semantics (mostly
-    # for the different meanings of update/render).
-    interface.implementsOnly(interfaces.IGrokForm)
-
-    template = default_form_template
-
-    def applyData(self, obj, **data):
-        return formlib.apply_data_event(obj, self.form_fields, data,
-                                        self.adapters, update=True)
-
-    # BBB -- to be removed in June 2007
-    def applyChanges(self, obj, **data):
-        warnings.warn("The 'applyChanges' method on forms is deprecated "
-                      "and will disappear by June 2007. Please use "
-                      "'applyData' instead.", DeprecationWarning, 2)
-        return bool(self.applyData(obj, **data))
-
-    @formlib.action("Apply")
-    def handle_edit_action(self, **data):
-        if self.applyData(self.context, **data):
-            formatter = self.request.locale.dates.getFormatter(
-                'dateTime', 'medium')
-
-            try:
-                time_zone = idatetime.ITZInfo(self.request)
-            except TypeError:
-                time_zone = pytz.UTC
-
-            self.status = "Updated on %s" % formatter.format(
-                datetime.datetime.now(time_zone)
-                )
-        else:
-            self.status = 'No changes'
-
-
-class DisplayForm(GrokForm, form.DisplayFormBase, View):
-    # We're only reusing the form implementation from zope.formlib, we
-    # explicitly don't want to inherit the interface semantics (mostly
-    # for the different meanings of update/render).
-    interface.implementsOnly(interfaces.IGrokForm)
-
-    template = default_display_template
-
-
-class IndexesClass(object):
-    def __init__(self, name, bases=(), attrs=None):
-        if attrs is None:
-            return
-        # make sure we take over a bunch of possible attributes
-        for name in ['__grok_context__', '__grok_name__',
-                     '__grok_site__']:
-            value = attrs.get(name)
-            if value is not None:
-                setattr(self, name, value)
-        # now read and store indexes
-        indexes = {}
-        for name, value in attrs.items():
-            if not interfaces.IIndexDefinition.providedBy(value):
-                continue
-            indexes[name] = value
-        self.__grok_indexes__ = indexes
-        # __grok_module__ is needed to make defined_locally() return True for
-        # inline templates
-        self.__grok_module__ = martian.util.caller_module()
-
-Indexes = IndexesClass('Indexes')
-
-class Permission(Permission):
-    pass
-
-class Role(Role):
-    pass
-
-class IGrokLayer(interface.Interface):
-    pass
-
-class IRESTLayer(interface.Interface):
-    pass
-
-class Skin(object):
-    pass
-
-class RESTProtocol(object):
-    pass
-
-class ViewletManager(ViewletManagerBase):
-    template = None
-
-    def __init__(self, context, request, view):
-        super(ViewletManager, self).__init__(context, request, view)
-        self.__name__ = util.class_annotation(self.__class__,
-                                              'grok.name',
-                                              self.__class__.__name__.lower())
-        self.static = component.queryAdapter(
-            self.request,
-            interface.Interface,
-            name=self.module_info.package_dotted_name
-            )
-
-    def render(self):
-        """See zope.contentprovider.interfaces.IContentProvider"""
-        # Now render the view
-        if self.template:
-            return self.template.render(self) 
-        else:
-            viewlets = util.sort_components(self.viewlets)
-            return u'\n'.join([viewlet.render() for viewlet in viewlets])
-
-    def namespace(self):
-        return {}
-
-    @property
-    def response(self):
-        return self.request.response
-
-    def url(self, obj=None, name=None):
-        # if the first argument is a string, that's the name. There should
-        # be no second argument
-        if isinstance(obj, basestring):
-            if name is not None:
-                raise TypeError(
-                    'url() takes either obj argument, obj, string arguments, '
-                    'or string argument')
-            name = obj
-            obj = None
-
-        if name is None and obj is None:
-            # create URL to view itself
-            obj = self
-        elif name is not None and obj is None:
-            # create URL to view on context
-            obj = self.context
-        return util.url(self.request, obj, name)
-
-    def redirect(self, url):
-        return self.request.response.redirect(url)
-
-class Viewlet(ViewletBase):
-    """ Batteries included viewlet """
-
-
-    def __init__(self, context, request, view, manager):
-        super(Viewlet, self).__init__(context, request, view, manager)
-        # would be nice to move this to the ViewletGrokker but
-        # new objects don't have __name__ of their class
-        self.__name__ = util.class_annotation(self.__class__,
-                                             'grok.name',
-                                              self.__class__.__name__.lower())
-        self.static = component.queryAdapter(
-            self.request,
-            interface.Interface,
-            name=self.module_info.package_dotted_name
-            )
-
-    @property
-    def response(self):
-        return self.request.response
-
-    def render(self):
-        return self.template.render(self)
-
-    def namespace(self):
-        return {}
-
-    def url(self, obj=None, name=None):
-        # if the first argument is a string, that's the name. There should
-        # be no second argument
-        if isinstance(obj, basestring):
-            if name is not None:
-                raise TypeError(
-                    'url() takes either obj argument, obj, string arguments, '
-                    'or string argument')
-            name = obj
-            obj = None
-
-        if name is None and obj is None:
-            # create URL to view itself
-            obj = self
-        elif name is not None and obj is None:
-            # create URL to view on context
-            obj = self.context
-        return util.url(self.request, obj, name)
-
-    def update(self):
-        pass

Modified: grokcore.component/trunk/src/grok/configure.zcml
===================================================================
--- grokcore.component/trunk/src/grok/configure.zcml	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/configure.zcml	2008-03-17 21:22:53 UTC (rev 84750)
@@ -27,65 +27,4 @@
   <include package="zope.app.renderer" />
   <include package="zope.app.session" />
 
-  <securityPolicy
-      component="zope.securitypolicy.zopepolicy.ZopeSecurityPolicy" />
-
-  <adapter factory=".components.ModelTraverser" />
-  <adapter factory=".components.ContainerTraverser" />
-
-  <browser:defaultView
-      for=".components.Model"
-      name="index"
-      />
-  <browser:defaultView
-      for=".components.Container"
-      name="index"
-      />
-
-  <subscriber handler=".components.addSiteHandler" />
-
-  <!-- we register a ++rest++ traversal namespace -->
-  <adapter
-      factory=".rest.rest_skin"
-      for="* zope.publisher.interfaces.browser.IHTTPRequest"
-      provides="zope.traversing.interfaces.ITraversable"
-      name="rest"
-      />
-
-  <!-- this overrides Zope 3's publication factories because they have
-       the same name; we also need to change the priority because of
-       the ZCML discriminator -->
-  <publisher
-      name="XMLRPC"
-      factory=".publication.GrokXMLRPCFactory"
-      methods="POST"
-      mimetypes="text/xml"
-      priority="21"
-      />
-
-  <publisher
-      name="BROWSER"
-      factory=".publication.GrokBrowserFactory"
-      methods="GET POST HEAD"
-      mimetypes="*"
-      priority="11"
-      />
-
-  <publisher
-      name="HTTP"
-      factory=".publication.GrokHTTPFactory"
-      methods="*"
-      mimetypes="*"
-      priority="1"
-      />
-
-  <!-- need to grok this for some basic REST support -->
-  <grok:grok package=".rest" />
-
-  <!-- ZPT support -->
-  <grok:grok package=".templatereg" />
-
-  <!-- The admin interface -->
-  <grok:grok package=".admin" />
-
 </configure>

Modified: grokcore.component/trunk/src/grok/decorators.py
===================================================================
--- grokcore.component/trunk/src/grok/decorators.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/decorators.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -17,30 +17,8 @@
 import types
 from zope.component._declaration import adapter as _adapter
 from zope.interface.declarations import implementer as _implementer
-from martian.util import frame_is_module
 from martian.error import GrokImportError
 
-class subscribe:
-
-    def __init__(self, *args):
-        self.subscribed = args
-
-    def __call__(self, function):
-        frame = sys._getframe(1)
-        if not frame_is_module(frame):
-            raise GrokImportError("@grok.subscribe can only be used on module "
-                                  "level.")
-
-        if not self.subscribed:
-            raise GrokImportError("@grok.subscribe requires at least one "
-                                  "argument.")
-
-        subscribers = frame.f_locals.get('__grok_subscribers__', None)
-        if subscribers is None:
-            frame.f_locals['__grok_subscribers__'] = subscribers = []
-        subscribers.append((function, self.subscribed))
-        return function
-
 class adapter(_adapter):
 
     def __init__(self, *interfaces):

Modified: grokcore.component/trunk/src/grok/directive.py
===================================================================
--- grokcore.component/trunk/src/grok/directive.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/directive.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -57,46 +57,6 @@
         self.name = name
 
 
-class LocalUtilityDirective(MultipleTimesDirective):
-    def check_arguments(self, factory, provides=None, name=u'',
-                        setup=None, public=False, name_in_container=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)
-
-    def value_factory(self, *args, **kw):
-        return LocalUtilityInfo(*args, **kw)
-
-
-class LocalUtilityInfo(object):
-    def __init__(self, factory, provides=None, name=u'',
-                 setup=None, public=False, name_in_container=None):
-        self.factory = factory
-        if provides is None:
-            provides = util.class_annotation(factory, 'grok.provides', None)
-        self.provides = provides
-        self.name = name
-        self.setup = setup
-        self.public = public
-        self.name_in_container = name_in_container
-
-
-class RequireDirective(BaseTextDirective, SingleValue, MultipleTimesDirective):
-
-    def store(self, frame, value):
-        super(RequireDirective, self).store(frame, value)
-        values = frame.f_locals.get(self.local_name, [])
-
-        # grok.require can be used both as a class-level directive and
-        # as a decorator for methods.  Therefore we return a decorator
-        # here, which may be used for methods, or simply ignored when
-        # used as a directive.
-        def decorator(func):
-            permission = values.pop()
-            func.__grok_require__ = permission
-            return func
-        return decorator
-
 class MultiValueOnceDirective(OnceDirective):
 
     def check_arguments(self, *values):
@@ -120,27 +80,12 @@
 
 # Define grok directives
 name = SingleTextDirective('grok.name', ClassDirectiveContext())
-template = SingleTextDirective('grok.template', ClassDirectiveContext())
 context = InterfaceOrClassDirective('grok.context',
                                     ClassOrModuleDirectiveContext())
-templatedir = SingleTextDirective('grok.templatedir', ModuleDirectiveContext())
 provides = InterfaceDirective('grok.provides', ClassDirectiveContext())
 baseclass = MarkerDirective('grok.baseclass', ClassDirectiveContext())
 global_utility = GlobalUtilityDirective('grok.global_utility',
                                         ModuleDirectiveContext())
-local_utility = LocalUtilityDirective('grok.local_utility',
-                                      ClassDirectiveContext())
-require = RequireDirective('grok.require', ClassDirectiveContext())
-site = InterfaceOrClassDirective('grok.site',
-                                 ClassDirectiveContext())
 title = SingleTextDirective('grok.title', ClassDirectiveContext())
-permissions = MultiValueOnceDirective(
-    'grok.permissions', ClassDirectiveContext())
-layer = InterfaceOrClassDirective('grok.layer',
-                           ClassOrModuleDirectiveContext())
 order = OrderDirective('grok.order', ClassDirectiveContext())
 direct = MarkerDirective('grok.direct', ClassDirectiveContext())
-viewletmanager = InterfaceOrClassDirective('grok.viewletmanager',
-                                           ClassOrModuleDirectiveContext())
-view = InterfaceOrClassDirective('grok.view',
-                                 ClassOrModuleDirectiveContext())

Deleted: grokcore.component/trunk/src/grok/formlib.py
===================================================================
--- grokcore.component/trunk/src/grok/formlib.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/formlib.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -1,124 +0,0 @@
-import types
-from zope import interface, event, lifecycleevent
-from zope.interface.interfaces import IInterface
-from zope.formlib import form
-from zope.schema.interfaces import IField
-
-class action(form.action):
-    """We override the action decorator we pass in our custom Action.
-    """
-    def __call__(self, success):
-        action = Action(self.label, success=success, **self.options)
-        self.actions.append(action)
-        return action
-
-class Action(form.Action):
-    def success(self, data):
-        if self.success_handler is not None:
-            return self.success_handler(self.form, **data)
-
-def Fields(*args, **kw):
-    fields = []
-    for key, value in kw.items():
-        if IField.providedBy(value):
-            value.__name__ = key
-            fields.append(value)
-            del kw[key]
-    fields.sort(key=lambda field: field.order)
-    return form.Fields(*(args + tuple(fields)), **kw)
-
-def get_auto_fields(context):
-    """Get the form fields for context.
-    """
-    # for an interface context, we generate them from that interface
-    if IInterface.providedBy(context):
-        return form.Fields(context)
-    # if we have a non-interface context, we're autogenerating them
-    # from any schemas defined by the context
-    fields = form.Fields(*most_specialized_interfaces(context))
-    # we pull in this field by default, but we don't want it in our form
-    fields = fields.omit('__name__')
-    return fields
-
-AutoFields = get_auto_fields
-
-def most_specialized_interfaces(context):
-    """Get interfaces for an object without any duplicates.
-
-    Interfaces in a declaration for an object may already have been seen
-    because it is also inherited by another interface. Don't return the
-    interface twice, as that would result in duplicate names when creating
-    the form.
-    """
-    declaration = interface.implementedBy(context)
-    seen = []
-    for iface in declaration.flattened():
-        if interface_seen(seen, iface):
-            continue
-        seen.append(iface)
-    return seen
-
-def interface_seen(seen, iface):
-    """Return True if interface already is seen.
-    """
-    for seen_iface in seen:
-        if seen_iface.extends(iface):
-            return True
-    return False
-
-def apply_data(context, form_fields, data, adapters=None, update=False):
-    """Save form data (``data`` dict) on a ``context`` object.
-
-    This is a beefed up version of zope.formlib.form.applyChanges().
-    It allows you to specify whether values should be compared with
-    the attributes on already existing objects or not, using the
-    ``update`` parameter.
-
-    Unlike zope.formlib.form.applyChanges(), it will return a
-    dictionary of interfaces and their fields that were changed.  This
-    is necessary to appropriately send IObjectModifiedEvents.
-    """
-    if adapters is None:
-        adapters = {}
-
-    changes = {}
-
-    for form_field in form_fields:
-        field = form_field.field
-        # Adapt context, if necessary
-        interface = field.interface
-        adapter = adapters.get(interface)
-        if adapter is None:
-            if interface is None:
-                adapter = context
-            else:
-                adapter = interface(context)
-            adapters[interface] = adapter
-
-        name = form_field.__name__
-        newvalue = data.get(name, form_field) # using form_field as marker
-
-        if update:
-            if ((newvalue is not form_field) and
-                (field.get(adapter) != newvalue)):
-                field.set(adapter, newvalue)
-                changes.setdefault(interface, []).append(name)
-        else:
-            if newvalue is not form_field:
-                field.set(adapter, newvalue)
-                changes.setdefault(interface, []).append(name)
-
-    return changes
-
-def apply_data_event(context, form_fields, data, adapters=None, update=False):
-    """Like apply_data, but also sends an IObjectModifiedEvent.
-    """
-    changes = apply_data(context, form_fields, data, adapters, update)
-
-    if changes:
-        descriptions = []
-        for interface, names in changes.items():
-            descriptions.append(lifecycleevent.Attributes(interface, *names))
-        event.notify(lifecycleevent.ObjectModifiedEvent(context, *descriptions))
-
-    return changes

Deleted: grokcore.component/trunk/src/grok/index.py
===================================================================
--- grokcore.component/trunk/src/grok/index.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/index.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -1,60 +0,0 @@
-import sys
-
-from zope.interface import implements
-from zope.interface.interfaces import IMethod, IInterface
-
-from zope.app.catalog.field import FieldIndex
-from zope.app.catalog.text import TextIndex
-from zc.catalog.catalogindex import SetIndex
-
-from martian.error import GrokError, GrokImportError
-from martian.util import frame_is_class
-
-from grok.interfaces import IIndexDefinition
-
-class IndexDefinition(object):
-    implements(IIndexDefinition)
-
-    index_class = None
-
-    def __init__(self, *args, **kw):
-        frame = sys._getframe(1)
-        if not frame_is_class(frame):
-            raise GrokImportError(
-                "%r can only be instantiated on class level." % self.__class__)
-        # store any extra parameters to pass to index later
-        self._args = args
-        self._attribute = kw.pop('attribute', None)
-        self._kw = kw
-
-    def setup(self, catalog, name, context, module_info):
-        if self._attribute is not None:
-            field_name = self._attribute
-        else:
-            field_name = name
-
-        if IInterface.providedBy(context):
-            try:
-                method = context[field_name]
-            except KeyError:
-                raise GrokError("grok.Indexes in %r refers to an attribute or "
-                                "method %r on interface %r, but this does not "
-                                "exist." % (module_info.getModule(),
-                                            field_name, context), None)
-            call = IMethod.providedBy(method)
-        else:
-            call = callable(getattr(context, field_name, None))
-            context = None # no interface lookup
-        catalog[name] = self.index_class(field_name=field_name,
-                                         interface=context,
-                                         field_callable=call,
-                                         *self._args, **self._kw)
-
-class Field(IndexDefinition):
-    index_class = FieldIndex
-
-class Text(IndexDefinition):
-    index_class = TextIndex
-
-class Set(IndexDefinition):
-    index_class = SetIndex

Modified: grokcore.component/trunk/src/grok/meta.py
===================================================================
--- grokcore.component/trunk/src/grok/meta.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/meta.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -44,7 +44,7 @@
 
     def grok(self, name, module, module_info, config, **kw):
         context = determine_module_component(module_info, 'grok.context',
-                                             [grok.Model, grok.Container])
+                                             [grok.Context])
         module.__grok_context__ = context
         return True
 

Deleted: grokcore.component/trunk/src/grok/publication.py
===================================================================
--- grokcore.component/trunk/src/grok/publication.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/publication.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -1,90 +0,0 @@
-##############################################################################
-#
-# Copyright (c) 2007 Zope Corporation 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 publication objects
-"""
-
-from grok.rest import GrokMethodNotAllowed
-
-from zope import component
-from zope.security.proxy import removeSecurityProxy
-from zope.security.checker import selectChecker
-from zope.publisher.publish import mapply
-
-from zope.app.publication.http import BaseHTTPPublication, HTTPPublication
-from zope.app.publication.browser import BrowserPublication
-from zope.app.publication.requestpublicationfactories import \
-     BrowserFactory, XMLRPCFactory, HTTPFactory
-from zope.app.http.interfaces import IHTTPException
-
-class ZopePublicationSansProxy(object):
-
-    def getApplication(self, request):
-        result = super(ZopePublicationSansProxy, self).getApplication(request)
-        return removeSecurityProxy(result)
-
-    def traverseName(self, request, ob, name):
-        result = super(ZopePublicationSansProxy, self).traverseName(
-            request, ob, name)
-        return removeSecurityProxy(result)
-
-    def callObject(self, request, ob):
-        checker = selectChecker(ob)
-        if checker is not None:
-            checker.check(ob, '__call__')
-        return super(ZopePublicationSansProxy, self).callObject(request, ob)
-
-
-class GrokBrowserPublication(ZopePublicationSansProxy, BrowserPublication):
-
-    def getDefaultTraversal(self, request, ob):
-        obj, path = super(GrokBrowserPublication, self).getDefaultTraversal(
-            request, ob)
-        return removeSecurityProxy(obj), path
-
-
-class GrokBrowserFactory(BrowserFactory):
-
-    def __call__(self):
-        request, publication = super(GrokBrowserFactory, self).__call__()
-        return request, GrokBrowserPublication
-
-
-class GrokXMLRPCPublication(ZopePublicationSansProxy, BaseHTTPPublication):
-    pass
-
-class GrokXMLRPCFactory(XMLRPCFactory):
-
-    def __call__(self):
-        request, publication = super(GrokXMLRPCFactory, self).__call__()
-        return request, GrokXMLRPCPublication
-
-
-class GrokHTTPPublication(ZopePublicationSansProxy, HTTPPublication):
-   def callObject(self, request, ob):
-       orig = ob
-       if not IHTTPException.providedBy(ob):
-           ob = component.queryMultiAdapter((ob, request),
-                                            name=request.method)
-           checker = selectChecker(ob)
-           if checker is not None:
-               checker.check(ob, '__call__')
-           ob = getattr(ob, request.method, None)
-           if ob is None:
-               raise GrokMethodNotAllowed(orig, request)
-       return mapply(ob, request.getPositionalArguments(), request)
-
-class GrokHTTPFactory(HTTPFactory):
-    def __call__(self):
-        request, publication = super(GrokHTTPFactory, self).__call__()
-        return request, GrokHTTPPublication

Deleted: grokcore.component/trunk/src/grok/rest.py
===================================================================
--- grokcore.component/trunk/src/grok/rest.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/rest.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -1,84 +0,0 @@
-import grok
-
-from zope import component
-
-from zope.traversing.namespace import skin
-from zope.interface import Interface
-from zope.interface.interfaces import IInterface
-from zope.publisher.interfaces.browser import IBrowserRequest
-from zope.publisher.interfaces.browser import IBrowserPublisher
-from zope.publisher.interfaces.http import IHTTPRequest
-from zope.app.publication.http import MethodNotAllowed
-import zope.location
-
-from grok.interfaces import IRESTSkinType
-
-class RestPublisher(zope.location.Location):
-    grok.implements(IBrowserPublisher)
-
-    def __init__(self, context, request):
-        self.context = context
-        self.request = request
-        self.__parent__ = self.context
-
-class GrokMethodNotAllowed(MethodNotAllowed):
-    pass
-
-class MethodNotAllowedView(grok.MultiAdapter):
-    grok.adapts(GrokMethodNotAllowed, IHTTPRequest)
-    grok.name('index.html')
-    grok.implements(Interface)
-    
-    def __init__(self, error, request):
-        self.error = error
-        self.request = request
-        self.allow = self._getAllow()
-        
-    def _getAllow(self):
-        allow = []
-        for method in ['GET', 'PUT', 'POST', 'DELETE']:
-            view = component.queryMultiAdapter(
-                (self.error.object, self.error.request),
-                name=method)
-            if view is not None:
-                is_not_allowed = getattr(view, 'is_not_allowed', False)
-                if not is_not_allowed:
-                    allow.append(method)
-        allow.sort()
-        return allow
-    
-    def __call__(self):
-        self.request.response.setHeader('Allow', ', '.join(self.allow))
-        self.request.response.setStatus(405)
-        return 'Method Not Allowed'
-    
-class rest_skin(skin):
-    skin_type = IRESTSkinType
-
-class DefaultRest(grok.REST):
-    grok.context(Interface)
-    grok.layer(grok.IRESTLayer)
-
-class NotAllowedREST(grok.REST):
-    """These are registered for everything by default to cause the correct
-    errors.
-
-    Any more specific REST view overrides this.
-    """
-    grok.layer(grok.IRESTLayer)
-    grok.context(Interface)
-
-    is_not_allowed = True
-    
-    def GET(self):
-        raise GrokMethodNotAllowed(self.context, self.request)
-            
-    def POST(self):
-        raise GrokMethodNotAllowed(self.context, self.request)
-            
-    def PUT(self):
-        raise GrokMethodNotAllowed(self.context, self.request)
-    
-    def DELETE(self):
-        raise GrokMethodNotAllowed(self.context, self.request)
-            

Deleted: grokcore.component/trunk/src/grok/templatereg.py
===================================================================
--- grokcore.component/trunk/src/grok/templatereg.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/templatereg.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -1,125 +0,0 @@
-from martian.error import GrokError
-from martian import util
-
-import os
-import zope.component
-import grok
-import warnings
-
-class TemplateRegistry(object):
-
-    def __init__(self):
-        self._reg = {}
-
-    def register(self, name, template):
-        self._reg[name] = dict(template=template, associated=False)
-
-    def markAssociated(self, name):
-        self._reg[name]['associated'] = True
-
-    def get(self, name):
-        entry = self._reg.get(name)
-        if entry is None:
-            return None
-        return entry['template']
-
-    def findFilesystem(self, module_info):
-        template_dir_name = module_info.getAnnotation(
-            'grok.templatedir', module_info.name + '_templates')
-
-        template_dir = module_info.getResourcePath(template_dir_name)
-
-        if not os.path.isdir(template_dir):
-            return
-
-        for template_file in os.listdir(template_dir):
-            if template_file.startswith('.') or template_file.endswith('~'):
-                continue
-
-            template_name, extension = os.path.splitext(template_file)
-            extension = extension[1:] # Get rid of the leading dot.
-            template_factory = zope.component.queryUtility(
-                grok.interfaces.ITemplateFileFactory,
-                name=extension)
-
-            if template_factory is None:
-                # Warning when importing files. This should be
-                # allowed because people may be using editors that generate
-                # '.bak' files and such.
-                warnings.warn("File '%s' has an unrecognized extension in "
-                              "directory '%s'" %
-                              (template_file, template_dir), UserWarning, 2)
-                continue
-
-            inline_template = self.get(template_name)
-            if inline_template:
-                raise GrokError("Conflicting templates found for name '%s' "
-                                "in module %r, either inline and in template "
-                                "directory '%s', or two templates with the "
-                                "same name and different extensions."
-                                % (template_name, module_info.getModule(),
-                                   template_dir), inline_template)
-
-            template = template_factory(template_file, template_dir)
-            template_path = os.path.join(template_dir, template_file)
-            template._annotateGrokInfo(template_name, template_path)
-
-            self.register(template_name, template)
-
-    def listUnassociated(self):
-        for name, entry in self._reg.iteritems():
-            if not entry['associated']:
-                yield name
-
-    def checkUnassociated(self, module_info):
-        unassociated = list(self.listUnassociated())
-        if unassociated:
-            msg = (
-                "Found the following unassociated template(s) when "
-                "grokking %r: %s.  Define view classes inheriting "
-                "from grok.View to enable the template(s)." % (
-                module_info.dotted_name, ', '.join(unassociated)))
-            warnings.warn(msg, UserWarning, 2)
-
-    def checkTemplates(self, module_info, factory, component_name,
-                       has_render, has_no_render):
-        factory_name = factory.__name__.lower()
-        template_name = util.class_annotation(factory, 'grok.template',
-                                              factory_name)
-
-        if factory_name != template_name:
-            # grok.template is being used
-
-            if self.get(factory_name):
-                raise GrokError("Multiple possible templates for %s %r. It "
-                                "uses grok.template('%s'), but there is also "
-                                "a template called '%s'."
-                                % (component_name, factory, template_name,
-                                   factory_name), factory)
-        template = self.get(template_name)
-        if template is not None:
-            if has_render(factory):
-                # we do not accept render and template both for a view
-                # (unless it's a form, they happen to have render.
-                raise GrokError(
-                    "Multiple possible ways to render %s %r. "
-                    "It has both a 'render' method as well as "
-                    "an associated template." %
-                    (component_name, factory), factory)
-            self.markAssociated(template_name)
-            factory.template = template
-            template._initFactory(factory)
-        else:
-            if has_no_render(factory):
-                # we do not accept a view without any way to render it
-                raise GrokError("%s %r has no associated template or "
-                                "'render' method." %
-                                (component_name.title(), factory), factory)
-
-class PageTemplateFileFactory(grok.GlobalUtility):
-
-    grok.implements(grok.interfaces.ITemplateFileFactory)
-    grok.name('pt')
-
-    def __call__(self, filename, _prefix=None):
-        return grok.components.PageTemplate(filename=filename, _prefix=_prefix)

Modified: grokcore.component/trunk/src/grok/testing.py
===================================================================
--- grokcore.component/trunk/src/grok/testing.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/testing.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -23,8 +23,9 @@
 import re
 from zope.testing import doctest, cleanup
 from zope.app.testing.functional import (
-    HTTPCaller, getRootFolder, FunctionalTestSetup,
-    sync, ZCMLLayer, FunctionalDocFileSuite)
+    HTTPCaller, getRootFolder, sync)
+#, FunctionalDocFileSuite
+#, FunctionalTestSetup
 
 class BasicTestSetup(object):
     """A basic test setup for a package.
@@ -162,7 +163,6 @@
 def grok(module_name):
     config = ConfigurationMachine()
     zcml.do_grok('grok.meta', config)
-    zcml.do_grok('grok.templatereg', config)
     zcml.do_grok(module_name, config)
     config.execute_actions()
 

Modified: grokcore.component/trunk/src/grok/tests/directive/argumenterror.py
===================================================================
--- grokcore.component/trunk/src/grok/tests/directive/argumenterror.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/tests/directive/argumenterror.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -2,5 +2,5 @@
    >>> import grok.tests.directive.argumenterror_fixture
    Traceback (most recent call last):
      ...
-   TypeError: grok.templatedir takes exactly 1 argument (3 given)
+   TypeError: grok.name takes exactly 1 argument (3 given)
 """

Modified: grokcore.component/trunk/src/grok/tests/directive/argumenterror_fixture.py
===================================================================
--- grokcore.component/trunk/src/grok/tests/directive/argumenterror_fixture.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/tests/directive/argumenterror_fixture.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -1,3 +1,3 @@
 import grok
 
-grok.templatedir('too', 'many', 'arguments')
+grok.name('too', 'many', 'arguments')

Modified: grokcore.component/trunk/src/grok/util.py
===================================================================
--- grokcore.component/trunk/src/grok/util.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/util.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -14,17 +14,9 @@
 """Grok utility functions.
 """
 
-import urllib
-
-import zope.location.location
 from zope import component
-from zope.traversing.browser.interfaces import IAbsoluteURL
-from zope.traversing.browser.absoluteurl import _safe as SAFE_URL_CHARACTERS
 
-from zope.security.checker import NamesChecker, defineChecker
-from zope.security.interfaces import IPermission
-
-from martian.error import GrokError, GrokImportError
+from martian.error import GrokError
 from martian.util import class_annotation, methods_from_class, scan_for_classes
 
 def check_adapts(class_):
@@ -33,72 +25,6 @@
                         "(use grok.adapts to specify)."
                         % class_, class_)
 
-def make_checker(factory, view_factory, permission, method_names=None):
-    """Make a checker for a view_factory associated with factory.
-
-    These could be one and the same for normal views, or different
-    in case we make method-based views such as for JSON and XMLRPC.
-    """
-    if method_names is None:
-        method_names = ['__call__']
-    if permission is not None:
-        check_permission(factory, permission)
-    if permission is None or permission == 'zope.Public':
-        checker = NamesChecker(method_names)
-    else:
-        checker = NamesChecker(method_names, permission)
-    defineChecker(view_factory, checker)
-
-def check_permission(factory, permission):
-    """Check whether a permission is defined.
-
-    If not, raise error for factory.
-    """
-    if component.queryUtility(IPermission,
-                              name=permission) is None:
-       raise GrokError('Undefined permission %r in %r. Use '
-                       'grok.Permission first.'
-                       % (permission, factory), factory)
-
-def get_default_permission(factory):
-    """Determine the default permission for a view.
-
-    There can be only 0 or 1 default permission.
-    """
-    permissions = class_annotation(factory, 'grok.require', [])
-    if not permissions:
-        return None
-    if len(permissions) > 1:
-        raise GrokError('grok.require was called multiple times in '
-                        '%r. It may only be set once for a class.'
-                        % factory, factory)
-
-    result = permissions[0]
-    return result
-
-def url(request, obj, name=None):
-    """Given a request and an object, give the URL.
-
-    Optionally pass a third argument name which gets added to the URL.
-    """
-    url = component.getMultiAdapter((obj, request), IAbsoluteURL)()
-    if name is None:
-        return url
-    return url + '/' + urllib.quote(name.encode('utf-8'),
-                                    SAFE_URL_CHARACTERS)
-
-def safely_locate_maybe(obj, parent, name):
-    """Set an object's __parent__ (and __name__) if the object's
-    __parent__ attribute doesn't exist yet or is None.
-
-    If the object provides ILocation, __parent__ and __name__ will be
-    set directly.  A location proxy will be returned otherwise.
-    """
-    if getattr(obj, '__parent__', None) is not None:
-        return obj
-    # This either sets __parent__ or wraps 'obj' in a LocationProxy
-    return zope.location.location.located(obj, parent, name)
-
 def determine_class_directive(directive_name, factory, module_info,
                               default=None):
     directive = class_annotation(factory, directive_name, None)

Modified: grokcore.component/trunk/src/grok/zcml.py
===================================================================
--- grokcore.component/trunk/src/grok/zcml.py	2008-03-17 21:16:46 UTC (rev 84749)
+++ grokcore.component/trunk/src/grok/zcml.py	2008-03-17 21:22:53 UTC (rev 84750)
@@ -15,11 +15,11 @@
 
 from zope.interface import Interface
 from zope.configuration.fields import GlobalObject
-from zope.configuration.config import ConfigurationMachine
+#from zope.configuration.config import ConfigurationMachine
 
 import martian
-from martian import scan
-from martian.error import GrokError
+#from martian import scan
+#from martian.error import GrokError
 
 class IGrokDirective(Interface):
     """Grok a package or module."""



More information about the Checkins mailing list